feat(ts): client (#1)

Author: sambacha

.gitignore

@@ -4,7 +4,9 @@ cache/
 artifacts/
 logs
 *.log
-
+go/vendor
+go/imports
+go/build
 ## CVE-2021-21300 style exploits
 .\#*
 

.prettierrc.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "http://json.schemastore.org/prettierrc",
+  "arrowParens": "always",
+  "bracketSpacing": true,
+  "jsxBracketSameLine": false,
+  "jsxSingleQuote": false,
+  "printWidth": 80,
+  "proseWrap": "always",
+  "quoteProps": "as-needed",
+  "semi": true,
+  "singleQuote": true,
+  "tabWidth": 2,
+  "trailingComma": "all",
+  "endOfLine": "lf",
+  "useTabs": false
+}

codecov.yml

@@ -0,0 +1,10 @@
+coverage:
+  status:
+    project:
+      default:
+        branches: [master]
+        informational: true
+    patch:
+      default:
+        only_pulls: true # No patch status on single commits in master
+        informational: true

fns/getTransactionReceiptMined.ts

@@ -0,0 +1,26 @@
+
+export function getTransactionReceiptMined(txHash: string | any[], interval: number) {
+    const self = this;
+    const transactionReceiptAsync = (resolve: (arg0: any) => void, reject: (arg0: any) => void) => {
+        self.getTransactionReceipt(txHash, (error: any, receipt: any) => {
+            if (error) {
+                reject(error);
+            } else if (receipt == null) {
+                setTimeout(
+                    () => transactionReceiptAsync(resolve, reject),
+                    interval ? interval : 500);
+            } else {
+                resolve(receipt);
+            }
+        });
+    };
+
+    if (Array.isArray(txHash)) {
+        return Promise.all(txHash.map(
+            oneTxHash => self.getTransactionReceiptMined(oneTxHash, interval)));
+    } else if (typeof txHash === "string") {
+        return new Promise(transactionReceiptAsync);
+    } else {
+        throw new Error(`Invalid Type: ${txHash}`);
+    }
+};

go/.gitignore

@@ -0,0 +1,4 @@
+build
+vendor
+.DS_Store
+

go/build.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+export CGO_ENABLED=0
+export GO111MODULE=on
+go build -buildmode c-shared -o build/dgeth.dylib \ 
+    -ldflags "-w -extldflags \"-static\" -X \"main.version=0.1.0\"" 
+    github.com/sambacha/dgeth/main

go/chain/connection.go

@@ -0,0 +1,24 @@
+package chain
+
+import (
+	"context"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+type ReceiptProvider interface {
+	TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error)
+
+	// Force a block creation event if running in simulator
+	Commit()
+}
+
+type Backend interface {
+	bind.ContractBackend
+	ReceiptProvider
+	TransactionByHash(ctx context.Context, hash common.Hash) (tx *types.Transaction, isPending bool, err error)
+	HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error)
+}

go/check-list.sh

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+go list -m -json all

go/go.mod

@@ -0,0 +1,36 @@
+module github.com/sambacha/dgeth
+
+go 1.18
+
+require (
+	github.com/ethereum/go-ethereum v1.10.18
+	github.com/holiman/uint256 v1.2.0
+	github.com/pkg/errors v0.9.1
+)
+
+require (
+	github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6 // indirect
+	github.com/VictoriaMetrics/fastcache v1.6.0 // indirect
+	github.com/btcsuite/btcd v0.20.1-beta // indirect
+	github.com/cespare/xxhash/v2 v2.1.1 // indirect
+	github.com/deckarep/golang-set v1.8.0 // indirect
+	github.com/edsrzf/mmap-go v1.0.0 // indirect
+	github.com/go-ole/go-ole v1.2.1 // indirect
+	github.com/go-stack/stack v1.8.0 // indirect
+	github.com/golang/snappy v0.0.4 // indirect
+	github.com/google/uuid v1.2.0 // indirect
+	github.com/gorilla/websocket v1.4.2 // indirect
+	github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d // indirect
+	github.com/holiman/bloomfilter/v2 v2.0.3 // indirect
+	github.com/mattn/go-runewidth v0.0.9 // indirect
+	github.com/olekukonko/tablewriter v0.0.5 // indirect
+	github.com/prometheus/tsdb v0.7.1 // indirect
+	github.com/rjeczalik/notify v0.9.1 // indirect
+	github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible // indirect
+	github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 // indirect
+	github.com/tklauser/go-sysconf v0.3.5 // indirect
+	github.com/tklauser/numcpus v0.2.2 // indirect
+	golang.org/x/crypto v0.0.0-20210921155107-089bfa567519 // indirect
+	golang.org/x/sys v0.0.0-20211019181941-9d821ace8654 // indirect
+	gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect
+)

go/go.sum

@@ -0,0 +1,250 @@
+package main
+
+import (
+	"context"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"log"
+	"math/big"
+	"math/rand"
+	"strconv"
+	"time"
+
+	"C"
+
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/sambacha/dgeth/simulator"
+)
+
+type TransactionRequest struct {
+	To    *string `json:"to"`
+	From  *string `json:"from"`
+	Nonce *string `json:"nonce"`
+
+	GasLimit *string `json:"gasLimit"`
+	GasPrice *string `json:"gasPrice"`
+
+	Data    *string `json:"data"`
+	Value   *string `json:"value"`
+	ChainId *uint64 `json:"chainId"`
+}
+
+func main() {}
+
+var (
+	simulators      = make(map[int]*simulator.Simulator)
+	nextSimulatorID = 0
+)
+
+//export newSimulator
+func newSimulator() C.int {
+	sim, err := simulator.NewSimulator()
+	if err != nil {
+		log.Fatal(err)
+	}
+	id := nextSimulatorID
+	simulators[id] = sim
+	nextSimulatorID++
+	return C.int(id)
+}
+
+//export getBlockNumber
+func getBlockNumber(simID C.int) *C.char {
+	sim := getSimulator(simID)
+	bn := sim.GetLatestBlockNumber()
+	return C.CString(bn.String())
+}
+
+//export getCode
+func getCode(simID C.int, account *C.char) *C.char {
+	sim := getSimulator(simID)
+	code, err := sim.Backend.CodeAt(context.Background(), common.HexToAddress(C.GoString(account)), nil)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	return C.CString(common.Bytes2Hex(code))
+}
+
+//export getChainID
+func getChainID(simID C.int) *C.char {
+	sim := getSimulator(simID)
+	bn := sim.GetChainID()
+	return C.CString(bn.String())
+}
+
+//export getBalance
+func getBalance(simID C.int, account *C.char) *C.char {
+	sim := getSimulator(simID)
+	bal, err := sim.Backend.BalanceAt(context.Background(), common.HexToAddress(C.GoString(account)), nil)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	return C.CString(bal.String())
+}
+
+//export getTransactionCount
+func getTransactionCount(simID C.int, account *C.char) C.int {
+	sim := getSimulator(simID)
+	count, err := sim.Backend.NonceAt(context.Background(), common.HexToAddress(C.GoString(account)), nil)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	return C.int(count)
+}
+
+//export getLogs
+func getLogs(simID C.int, queryJson *C.char) *C.char {
+	sim := getSimulator(simID)
+
+	var query ethereum.FilterQuery
+
+	err := json.Unmarshal([]byte(C.GoString(queryJson)), &query)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	logs, err := sim.Backend.FilterLogs(context.Background(), query)
+
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	logsJson, err := json.Marshal(logs)
+	return C.CString(string(logsJson))
+}
+
+//export call
+func call(simID C.int, msgJson *C.char) *C.char {
+	sim := getSimulator(simID)
+	var msg TransactionRequest
+
+	err := json.Unmarshal([]byte(C.GoString(msgJson)), &msg)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	var callMsg ethereum.CallMsg
+
+	if msg.From != nil {
+		callMsg.From = common.HexToAddress(*msg.From)
+	}
+	if msg.To != nil {
+		temp := common.HexToAddress(*msg.To)
+		callMsg.To = &temp
+	}
+	if msg.GasLimit != nil {
+		value, err := strconv.ParseUint(*msg.GasLimit, 16, 64)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		callMsg.Gas = value
+	}
+	if msg.GasPrice != nil {
+		callMsg.GasPrice = big.NewInt(0)
+		callMsg.GasPrice.SetString(*msg.GasPrice, 16)
+	}
+	if msg.Data != nil {
+		data, err := hex.DecodeString((*msg.Data)[2:])
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		callMsg.Data = data
+	}
+
+	res, err := sim.Backend.CallContract(context.Background(), callMsg, nil)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	return C.CString(hex.EncodeToString(res))
+}
+
+type txReceipt struct {
+	Tx        *types.Transaction
+	IsPending bool
+}
+
+//export getTransaction
+func getTransaction(simID C.int, txHash *C.char) *C.char {
+	sim := getSimulator(simID)
+
+	hash := common.HexToHash(C.GoString(txHash))
+	tx, isPending, err := sim.Backend.SimulatedBackend.TransactionByHash(context.Background(), hash)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	stringified, err := json.Marshal(txReceipt{Tx: tx, IsPending: isPending})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	return C.CString(string(stringified[:]))
+}
+
+//export sendTransaction
+func sendTransaction(simID C.int, txData *C.char) *C.char {
+	sim := getSimulator(simID)
+
+	bytes, err := hex.DecodeString(C.GoString(txData)[2:])
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	tx := &types.Transaction{}
+	err = tx.UnmarshalBinary(bytes)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = sim.Backend.SimulatedBackend.SendTransaction(context.Background(), tx)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	sim.Backend.Commit()
+
+	receipt, err := sim.Backend.SimulatedBackend.TransactionReceipt(context.Background(), tx.Hash())
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	receiptJson, err := json.Marshal(receipt)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	return C.CString(string(receiptJson))
+}
+
+func getSimulator(simID C.int) *simulator.Simulator {
+	id := int(simID)
+	sim, ok := simulators[id]
+	if !ok {
+		log.Fatal(fmt.Errorf("simulator with %d does not exist", id))
+	}
+	return sim
+}
+
+//export cgoCurrentMillis
+func cgoCurrentMillis() C.long {
+	return C.long(time.Now().Unix())
+}
+
+//export cgoSeed
+func cgoSeed(m C.long) {
+	rand.Seed(int64(m))
+}
+
+//export cgoRandom
+func cgoRandom(m C.int) C.int {
+	return C.int(rand.Intn(int(m)))
+}