Merge branch 'master' of https://github.com/sambacha/dgeth

Author: sambacha

README.md

@@ -0,0 +1,7 @@
+# d.geth
+
+[`a degenerate go-ethereum client`](#)
+
+----
+
+␆

go/make.sh

@@ -1,10 +1,18 @@
 #!/usr/bin/env bash
+
 export CGO_ENABLED=0
 export GO111MODULE=on
+#export PATH /toolchain/bin:/toolchain/go/bin
+export GOPROXY https://proxy.golang.org
+export GOCACHE /.cache/go-build
+export GOMODCACHE /.cache/mod
+echo "Building dgeth.."
+
 go build -buildmode c-shared -o build/dgeth.dylib -ldflags "-w -extldflags -static" github.com/sambacha/dgeth/main
 go build -buildmode c-archive -o build/dgeth.a github.com/sambacha/dgeth/main
 cp main/main.h build
 
+
 # 	go build -buildmode c-shared -o build/dgeth.node github.com/sambacha/dgeth/go-napi 
 # Path: go/build.sh
 #go build -buildmode c-shared -o build/dgeth.dll -ldflags "-w -extldflags -static" github.com/sambacha/dgeth/main
@@ -14,4 +22,4 @@ cp main/main.h build
 #go build -buildmode c-shared -o build/dgeth.app/Contents/MacOS/dgeth -ldflags "-w -extldflags -static" github.com/sambacha/dgeth/main
 #go build -buildmode c-shared -o build/dgeth.app/Contents/MacOS/dgeth.exe -ldflags "-w -extldflags -static" github.com/sambacha/dgeth/main
 #go build -buildmode c-shared -o build/dgeth.app/Contents/MacOS/dgeth.so -ldflags "-w -extldflags -static" github.com/sambacha/dgeth/main
-#go build -buildmode c-shared -o build/dgeth.app/Contents/MacOS/dgeth.dylib -ldflags "-w -extldflags -static" github.com/sambacha/dgeth/main
+#go build -buildmode c-shared -o build/dgeth.app/Contents/MacOS/dgeth.dylib -ldflags "-w -extldflags -static" github.com/sambacha/dgeth/main

go/setup.sh

@@ -1,3 +1,2 @@
 #!/bin/sh
-sudo port install dylibbundler || exit 1
 brew install dylibbundler

go/sim/main.go

@@ -0,0 +1,223 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/ethereum/hive/hivesim"
+)
+
+var (
+	clientEnv = hivesim.Params{
+		"HIVE_NODETYPE":       "full",
+		"HIVE_NETWORK_ID":     "1",
+		"HIVE_CHAIN_ID":       "1",
+		"HIVE_FORK_HOMESTEAD": "0",
+		//"HIVE_FORK_DAO_BLOCK":      2000,
+		"HIVE_FORK_TANGERINE":      "0",
+		"HIVE_FORK_SPURIOUS":       "0",
+		"HIVE_FORK_BYZANTIUM":      "0",
+		"HIVE_FORK_CONSTANTINOPLE": "0",
+		"HIVE_FORK_PETERSBURG":     "0",
+		"HIVE_FORK_ISTANBUL":       "0",
+		"HIVE_FORK_BERLIN":         "0",
+		"HIVE_FORK_LONDON":         "0",
+	}
+	files = map[string]string{
+		"genesis.json": "./tests/genesis.json",
+		"chain.rlp":    "./tests/chain.rlp",
+	}
+)
+
+type test struct {
+	Name string
+	Data []byte
+}
+
+func main() {
+	suite := hivesim.Suite{
+		Name: "rpc-compat",
+		Description: `
+The RPC-compatibility test suite runs a set of RPC related tests against a
+running node. It tests client implementations of the JSON-RPC API for
+conformance with the execution API specification.`[1:],
+	}
+	suite.Add(&hivesim.ClientTestSpec{
+		Role:        "eth1",
+		Name:        "client launch",
+		Description: `This test launches the client and collects its logs.`,
+		Parameters:  clientEnv,
+		Files:       files,
+		Run: func(t *hivesim.T, c *hivesim.Client) {
+			runAllTests(t, c, c.Type)
+		},
+		AlwaysRun: true,
+	})
+	sim := hivesim.New()
+	hivesim.MustRunSuite(sim, suite)
+}
+
+func runAllTests(t *hivesim.T, c *hivesim.Client, clientName string) {
+	_, testPattern := t.Sim.TestPattern()
+	re := regexp.MustCompile(testPattern)
+
+	tests := loadTests(t, "tests", re)
+	for _, test := range tests {
+		t.Run(hivesim.TestSpec{
+			Name: fmt.Sprintf("%s (%s)", test.Name, clientName),
+			Run: func(t *hivesim.T) {
+				if err := runTest(t, c, test.Data); err != nil {
+					t.Fatal(err)
+				}
+			},
+		})
+	}
+}
+
+func runTest(t *hivesim.T, c *hivesim.Client, data []byte) error {
+	var (
+		client = &http.Client{
+			Timeout: 5 * time.Second,
+			Transport: &loggingRoundTrip{
+				t:     t,
+				inner: http.DefaultTransport,
+			},
+		}
+		url  = fmt.Sprintf("http://%s", net.JoinHostPort(c.IP.String(), "8545"))
+		err  error
+		resp []byte
+	)
+
+	for _, line := range strings.Split(string(data), "\n") {
+		line = strings.TrimSpace(line)
+		switch {
+		case len(line) == 0 || strings.HasPrefix(line, "//"):
+			// Skip comments, blank lines.
+			continue
+		case strings.HasPrefix(line, ">> "):
+			// Send request.
+			resp, err = postHttp(client, url, []byte(line[3:]))
+			if err != nil {
+				return err
+			}
+		case strings.HasPrefix(line, "<< "):
+			// Read response. Unmarshal to interface{} to verify deep equality. Marshal
+			// again to remove padding differences and to print each field in the same
+			// order. This makes it easy to spot any discrepancies.
+			if resp == nil {
+				return fmt.Errorf("invalid test, response before request")
+			}
+			var want interface{}
+			if err := json.Unmarshal([]byte(strings.TrimSpace(line)[3:]), &want); err != nil {
+				return err
+			}
+			var got interface{}
+			if err := json.Unmarshal(resp, &got); err != nil {
+				return err
+			}
+			if !reflect.DeepEqual(want, got) {
+				want, _ := json.Marshal(want)
+				got, _ := json.Marshal(got)
+				return fmt.Errorf("invalid response\nwant: %s\ngot:  %s", want, got)
+			}
+			resp = nil
+		default:
+			t.Fatalf("invalid line in test script: %s", line)
+		}
+	}
+	if resp != nil {
+		t.Fatalf("unhandled response in test case")
+	}
+	return nil
+}
+
+// sendHttp sends an HTTP POST with the provided json data and reads the
+// response into a byte slice and returns it.
+func postHttp(c *http.Client, url string, d []byte) ([]byte, error) {
+	data := bytes.NewBuffer(d)
+	req, err := http.NewRequest("POST", url, data)
+	if err != nil {
+		return nil, fmt.Errorf("error building request: %v", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	resp, err := c.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("write error: %v", err)
+	}
+	return io.ReadAll(resp.Body)
+}
+
+// loggingRoundTrip writes requests and responses to the test log.
+type loggingRoundTrip struct {
+	t     *hivesim.T
+	inner http.RoundTripper
+}
+
+func (rt *loggingRoundTrip) RoundTrip(req *http.Request) (*http.Response, error) {
+	// Read and log the request body.
+	reqBytes, err := ioutil.ReadAll(req.Body)
+	req.Body.Close()
+	if err != nil {
+		return nil, err
+	}
+	rt.t.Logf(">>  %s", bytes.TrimSpace(reqBytes))
+	reqCopy := *req
+	reqCopy.Body = ioutil.NopCloser(bytes.NewReader(reqBytes))
+
+	// Do the round trip.
+	resp, err := rt.inner.RoundTrip(&reqCopy)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	// Read and log the response bytes.
+	respBytes, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+	respCopy := *resp
+	respCopy.Body = ioutil.NopCloser(bytes.NewReader(respBytes))
+	rt.t.Logf("<<  %s", bytes.TrimSpace(respBytes))
+	return &respCopy, nil
+}
+
+// loadTests walks the given directory looking for *.io files to load.
+func loadTests(t *hivesim.T, root string, re *regexp.Regexp) []test {
+	tests := make([]test, 0)
+	filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			t.Logf("unable to walk path: %s", err)
+			return err
+		}
+		if info.IsDir() {
+			return nil
+		}
+		if fname := info.Name(); !strings.HasSuffix(fname, ".io") {
+			return nil
+		}
+		pathname := strings.TrimSuffix(strings.TrimPrefix(path, root), ".io")
+		if !re.MatchString(pathname) {
+			fmt.Println("skip", pathname)
+			return nil // skip
+		}
+		data, err := ioutil.ReadFile(path)
+		if err != nil {
+			return err
+		}
+		tests = append(tests, test{strings.TrimLeft(pathname, "/"), data})
+		return nil
+	})
+	return tests
+}