diff --git a/abigen/accounts/abi/abi.go b/abigen/accounts/abi/abi.go
new file mode 100644
index 00000000..c440f77e
--- /dev/null
+++ b/abigen/accounts/abi/abi.go
@@ -0,0 +1,278 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package abi
+
+import (
+ "bytes"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "io"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/crypto"
+)
+
+type Chain string
+
+const (
+ Ethereum = "Ethereum"
+ Starknet = "Starknet"
+)
+
+// The ABI holds information about a contract's context and available
+// invokable methods. It will allow you to type check function calls and
+// packs data accordingly.
+type ABI struct {
+ Constructor Method
+ Methods map[string]Method
+ Events map[string]Event
+ Errors map[string]Error
+ Types map[string]Type
+
+ // Additional "special" functions introduced in solidity v0.6.0.
+ // It's separated from the original default fallback. Each contract
+ // can only define one fallback and receive function.
+ Fallback Method // Note it's also used to represent legacy fallback before v0.6.0
+ Receive Method
+}
+
+// JSON returns a parsed ABI interface and error if it failed.
+func JSON(reader io.Reader) (ABI, error) {
+ dec := json.NewDecoder(reader)
+
+ var abi ABI
+ if err := dec.Decode(&abi); err != nil {
+ return ABI{}, err
+ }
+ return abi, nil
+}
+
+// Pack the given method name to conform the ABI. Method call's data
+// will consist of method_id, args0, arg1, ... argN. Method id consists
+// of 4 bytes and arguments are all 32 bytes.
+// Method ids are created from the first 4 bytes of the hash of the
+// methods string signature. (signature = baz(uint32,string32))
+func (abi ABI) Pack(name string, args ...interface{}) ([]byte, error) {
+ // Fetch the ABI of the requested method
+ if name == "" {
+ // constructor
+ arguments, err := abi.Constructor.Inputs.Pack(args...)
+ if err != nil {
+ return nil, err
+ }
+ return arguments, nil
+ }
+ method, exist := abi.Methods[name]
+ if !exist {
+ return nil, fmt.Errorf("method '%s' not found", name)
+ }
+ arguments, err := method.Inputs.Pack(args...)
+ if err != nil {
+ return nil, err
+ }
+ // Pack up the method ID too if not a constructor and return
+ return append(method.ID, arguments...), nil
+}
+
+func (abi ABI) getArguments(name string, data []byte) (Arguments, error) {
+ // since there can't be naming collisions with contracts and events,
+ // we need to decide whether we're calling a method or an event
+ var args Arguments
+ if method, ok := abi.Methods[name]; ok {
+ if len(data)%32 != 0 {
+ return nil, fmt.Errorf("abi: improperly formatted output: %s - Bytes: [%+v]", string(data), data)
+ }
+ args = method.Outputs
+ }
+ if event, ok := abi.Events[name]; ok {
+ args = event.Inputs
+ }
+ if args == nil {
+ return nil, errors.New("abi: could not locate named method or event")
+ }
+ return args, nil
+}
+
+// Unpack unpacks the output according to the abi specification.
+func (abi ABI) Unpack(name string, data []byte) ([]interface{}, error) {
+ args, err := abi.getArguments(name, data)
+ if err != nil {
+ return nil, err
+ }
+ return args.Unpack(data)
+}
+
+// UnpackIntoInterface unpacks the output in v according to the abi specification.
+// It performs an additional copy. Please only use, if you want to unpack into a
+// structure that does not strictly conform to the abi structure (e.g. has additional arguments)
+func (abi ABI) UnpackIntoInterface(v interface{}, name string, data []byte) error {
+ args, err := abi.getArguments(name, data)
+ if err != nil {
+ return err
+ }
+ unpacked, err := args.Unpack(data)
+ if err != nil {
+ return err
+ }
+ return args.Copy(v, unpacked)
+}
+
+// UnpackIntoMap unpacks a log into the provided map[string]interface{}.
+func (abi ABI) UnpackIntoMap(v map[string]interface{}, name string, data []byte) (err error) {
+ args, err := abi.getArguments(name, data)
+ if err != nil {
+ return err
+ }
+ return args.UnpackIntoMap(v, data)
+}
+
+// UnmarshalJSON implements json.Unmarshaler interface.
+func (abi *ABI) UnmarshalJSON(data []byte) error {
+ var fields []struct {
+ Type string
+ Name string
+ Inputs []Argument
+ Outputs []Argument
+
+ // Status indicator which can be: "pure", "view",
+ // "nonpayable" or "payable".
+ StateMutability string
+
+ // Deprecated Status indicators, but removed in v0.6.0.
+ Constant bool // True if function is either pure or view
+ Payable bool // True if function is payable
+
+ // Event relevant indicator represents the event is
+ // declared as anonymous.
+ Anonymous bool
+
+ // specific fields for starknet
+ Size int
+ Chain Chain
+ }
+ if err := json.Unmarshal(data, &fields); err != nil {
+ return err
+ }
+ abi.Methods = make(map[string]Method)
+ abi.Events = make(map[string]Event)
+ abi.Errors = make(map[string]Error)
+ abi.Types = make(map[string]Type)
+ var chain Chain
+ for _, field := range fields {
+ switch field.Type {
+ case "constructor":
+ abi.Constructor = NewMethod("", "", Constructor, field.StateMutability, field.Constant, field.Payable, field.Inputs, nil)
+ case "function":
+ name := ResolveNameConflict(field.Name, func(s string) bool { _, ok := abi.Methods[s]; return ok })
+ abi.Methods[name] = NewMethod(name, field.Name, Function, field.StateMutability, field.Constant, field.Payable, field.Inputs, field.Outputs)
+ case "fallback":
+ // New introduced function type in v0.6.0, check more detail
+ // here https://solidity.readthedocs.io/en/v0.6.0/contracts.html#fallback-function
+ if abi.HasFallback() {
+ return errors.New("only single fallback is allowed")
+ }
+ abi.Fallback = NewMethod("", "", Fallback, field.StateMutability, field.Constant, field.Payable, nil, nil)
+ case "receive":
+ // New introduced function type in v0.6.0, check more detail
+ // here https://solidity.readthedocs.io/en/v0.6.0/contracts.html#fallback-function
+ if abi.HasReceive() {
+ return errors.New("only single receive is allowed")
+ }
+ if field.StateMutability != "payable" {
+ return errors.New("the statemutability of receive can only be payable")
+ }
+ abi.Receive = NewMethod("", "", Receive, field.StateMutability, field.Constant, field.Payable, nil, nil)
+ case "event":
+ name := ResolveNameConflict(field.Name, func(s string) bool { _, ok := abi.Events[s]; return ok })
+ abi.Events[name] = NewEvent(name, field.Name, field.Anonymous, field.Inputs, chain)
+ case "error":
+ // Errors cannot be overloaded or overridden but are inherited,
+ // no need to resolve the name conflict here.
+ abi.Errors[field.Name] = NewError(field.Name, field.Inputs)
+ case "struct":
+ var err error
+ abi.Types[field.Name], err = NewType(field.Type, "", nil)
+ if err != nil {
+ return err
+ }
+ case "-":
+ chain = field.Chain
+ continue
+ default:
+ return fmt.Errorf("abi: could not recognize type %v of field %v", field.Type, field.Name)
+ }
+ }
+ return nil
+}
+
+// MethodById looks up a method by the 4-byte id,
+// returns nil if none found.
+func (abi *ABI) MethodById(sigdata []byte) (*Method, error) {
+ if len(sigdata) < 4 {
+ return nil, fmt.Errorf("data too short (%d bytes) for abi method lookup", len(sigdata))
+ }
+ for _, method := range abi.Methods {
+ if bytes.Equal(method.ID, sigdata[:4]) {
+ return &method, nil
+ }
+ }
+ return nil, fmt.Errorf("no method with id: %#x", sigdata[:4])
+}
+
+// EventByID looks an event up by its topic hash in the
+// ABI and returns nil if none found.
+func (abi *ABI) EventByID(topic common.Hash) (*Event, error) {
+ for _, event := range abi.Events {
+ if bytes.Equal(event.ID.Bytes(), topic.Bytes()) {
+ return &event, nil
+ }
+ }
+ return nil, fmt.Errorf("no event with id: %#x", topic.Hex())
+}
+
+// HasFallback returns an indicator whether a fallback function is included.
+func (abi *ABI) HasFallback() bool {
+ return abi.Fallback.Type == Fallback
+}
+
+// HasReceive returns an indicator whether a receive function is included.
+func (abi *ABI) HasReceive() bool {
+ return abi.Receive.Type == Receive
+}
+
+// revertSelector is a special function selector for revert reason unpacking.
+var revertSelector = crypto.Keccak256([]byte("Error(string)"))[:4]
+
+// UnpackRevert resolves the abi-encoded revert reason. According to the solidity
+// spec https://solidity.readthedocs.io/en/latest/control-structures.html#revert,
+// the provided revert reason is abi-encoded as if it were a call to a function
+// `Error(string)`. So it's a special tool for it.
+func UnpackRevert(data []byte) (string, error) {
+ if len(data) < 4 {
+ return "", errors.New("invalid data for unpacking")
+ }
+ if !bytes.Equal(data[:4], revertSelector) {
+ return "", errors.New("invalid data for unpacking")
+ }
+ typ, _ := NewType("string", "", nil)
+ unpacked, err := (Arguments{{Type: typ}}).Unpack(data[4:])
+ if err != nil {
+ return "", err
+ }
+ return unpacked[0].(string), nil
+}
diff --git a/abigen/accounts/abi/abi_test.go b/abigen/accounts/abi/abi_test.go
new file mode 100644
index 00000000..cd9433ca
--- /dev/null
+++ b/abigen/accounts/abi/abi_test.go
@@ -0,0 +1,1160 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package abi
+
+import (
+ "bytes"
+ "encoding/hex"
+ "errors"
+ "fmt"
+ "math/big"
+ "reflect"
+ "strings"
+ "testing"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/math"
+ "github.com/ethereum/go-ethereum/crypto"
+)
+
+const jsondata = `
+[
+ { "type" : "function", "name" : ""},
+ { "type" : "function", "name" : "balance", "stateMutability" : "view" },
+ { "type" : "function", "name" : "send", "inputs" : [ { "name" : "amount", "type" : "uint256" } ] },
+ { "type" : "function", "name" : "test", "inputs" : [ { "name" : "number", "type" : "uint32" } ] },
+ { "type" : "function", "name" : "string", "inputs" : [ { "name" : "inputs", "type" : "string" } ] },
+ { "type" : "function", "name" : "bool", "inputs" : [ { "name" : "inputs", "type" : "bool" } ] },
+ { "type" : "function", "name" : "address", "inputs" : [ { "name" : "inputs", "type" : "address" } ] },
+ { "type" : "function", "name" : "uint64[2]", "inputs" : [ { "name" : "inputs", "type" : "uint64[2]" } ] },
+ { "type" : "function", "name" : "uint64[]", "inputs" : [ { "name" : "inputs", "type" : "uint64[]" } ] },
+ { "type" : "function", "name" : "int8", "inputs" : [ { "name" : "inputs", "type" : "int8" } ] },
+ { "type" : "function", "name" : "bytes32", "inputs" : [ { "name" : "inputs", "type" : "bytes32" } ] },
+ { "type" : "function", "name" : "foo", "inputs" : [ { "name" : "inputs", "type" : "uint32" } ] },
+ { "type" : "function", "name" : "bar", "inputs" : [ { "name" : "inputs", "type" : "uint32" }, { "name" : "string", "type" : "uint16" } ] },
+ { "type" : "function", "name" : "slice", "inputs" : [ { "name" : "inputs", "type" : "uint32[2]" } ] },
+ { "type" : "function", "name" : "slice256", "inputs" : [ { "name" : "inputs", "type" : "uint256[2]" } ] },
+ { "type" : "function", "name" : "sliceAddress", "inputs" : [ { "name" : "inputs", "type" : "address[]" } ] },
+ { "type" : "function", "name" : "sliceMultiAddress", "inputs" : [ { "name" : "a", "type" : "address[]" }, { "name" : "b", "type" : "address[]" } ] },
+ { "type" : "function", "name" : "nestedArray", "inputs" : [ { "name" : "a", "type" : "uint256[2][2]" }, { "name" : "b", "type" : "address[]" } ] },
+ { "type" : "function", "name" : "nestedArray2", "inputs" : [ { "name" : "a", "type" : "uint8[][2]" } ] },
+ { "type" : "function", "name" : "nestedSlice", "inputs" : [ { "name" : "a", "type" : "uint8[][]" } ] },
+ { "type" : "function", "name" : "receive", "inputs" : [ { "name" : "memo", "type" : "bytes" }], "outputs" : [], "payable" : true, "stateMutability" : "payable" },
+ { "type" : "function", "name" : "fixedArrStr", "stateMutability" : "view", "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "fixedArr", "type" : "uint256[2]" } ] },
+ { "type" : "function", "name" : "fixedArrBytes", "stateMutability" : "view", "inputs" : [ { "name" : "bytes", "type" : "bytes" }, { "name" : "fixedArr", "type" : "uint256[2]" } ] },
+ { "type" : "function", "name" : "mixedArrStr", "stateMutability" : "view", "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "fixedArr", "type" : "uint256[2]" }, { "name" : "dynArr", "type" : "uint256[]" } ] },
+ { "type" : "function", "name" : "doubleFixedArrStr", "stateMutability" : "view", "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "fixedArr1", "type" : "uint256[2]" }, { "name" : "fixedArr2", "type" : "uint256[3]" } ] },
+ { "type" : "function", "name" : "multipleMixedArrStr", "stateMutability" : "view", "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "fixedArr1", "type" : "uint256[2]" }, { "name" : "dynArr", "type" : "uint256[]" }, { "name" : "fixedArr2", "type" : "uint256[3]" } ] },
+ { "type" : "function", "name" : "overloadedNames", "stateMutability" : "view", "inputs": [ { "components": [ { "internalType": "uint256", "name": "_f", "type": "uint256" }, { "internalType": "uint256", "name": "__f", "type": "uint256"}, { "internalType": "uint256", "name": "f", "type": "uint256"}],"internalType": "struct Overloader.F", "name": "f","type": "tuple"}]}
+]`
+
+var (
+ Uint256, _ = NewType("uint256", "", nil)
+ Uint32, _ = NewType("uint32", "", nil)
+ Uint16, _ = NewType("uint16", "", nil)
+ String, _ = NewType("string", "", nil)
+ Bool, _ = NewType("bool", "", nil)
+ Bytes, _ = NewType("bytes", "", nil)
+ Bytes32, _ = NewType("bytes32", "", nil)
+ Address, _ = NewType("address", "", nil)
+ Uint64Arr, _ = NewType("uint64[]", "", nil)
+ AddressArr, _ = NewType("address[]", "", nil)
+ Int8, _ = NewType("int8", "", nil)
+ // Special types for testing
+ Uint32Arr2, _ = NewType("uint32[2]", "", nil)
+ Uint64Arr2, _ = NewType("uint64[2]", "", nil)
+ Uint256Arr, _ = NewType("uint256[]", "", nil)
+ Uint256Arr2, _ = NewType("uint256[2]", "", nil)
+ Uint256Arr3, _ = NewType("uint256[3]", "", nil)
+ Uint256ArrNested, _ = NewType("uint256[2][2]", "", nil)
+ Uint8ArrNested, _ = NewType("uint8[][2]", "", nil)
+ Uint8SliceNested, _ = NewType("uint8[][]", "", nil)
+ TupleF, _ = NewType("tuple", "struct Overloader.F", []ArgumentMarshaling{
+ {Name: "_f", Type: "uint256"},
+ {Name: "__f", Type: "uint256"},
+ {Name: "f", Type: "uint256"}})
+)
+
+var methods = map[string]Method{
+ "": NewMethod("", "", Function, "", false, false, nil, nil),
+ "balance": NewMethod("balance", "balance", Function, "view", false, false, nil, nil),
+ "send": NewMethod("send", "send", Function, "", false, false, []Argument{{"amount", Uint256, false}}, nil),
+ "test": NewMethod("test", "test", Function, "", false, false, []Argument{{"number", Uint32, false}}, nil),
+ "string": NewMethod("string", "string", Function, "", false, false, []Argument{{"inputs", String, false}}, nil),
+ "bool": NewMethod("bool", "bool", Function, "", false, false, []Argument{{"inputs", Bool, false}}, nil),
+ "address": NewMethod("address", "address", Function, "", false, false, []Argument{{"inputs", Address, false}}, nil),
+ "uint64[]": NewMethod("uint64[]", "uint64[]", Function, "", false, false, []Argument{{"inputs", Uint64Arr, false}}, nil),
+ "uint64[2]": NewMethod("uint64[2]", "uint64[2]", Function, "", false, false, []Argument{{"inputs", Uint64Arr2, false}}, nil),
+ "int8": NewMethod("int8", "int8", Function, "", false, false, []Argument{{"inputs", Int8, false}}, nil),
+ "bytes32": NewMethod("bytes32", "bytes32", Function, "", false, false, []Argument{{"inputs", Bytes32, false}}, nil),
+ "foo": NewMethod("foo", "foo", Function, "", false, false, []Argument{{"inputs", Uint32, false}}, nil),
+ "bar": NewMethod("bar", "bar", Function, "", false, false, []Argument{{"inputs", Uint32, false}, {"string", Uint16, false}}, nil),
+ "slice": NewMethod("slice", "slice", Function, "", false, false, []Argument{{"inputs", Uint32Arr2, false}}, nil),
+ "slice256": NewMethod("slice256", "slice256", Function, "", false, false, []Argument{{"inputs", Uint256Arr2, false}}, nil),
+ "sliceAddress": NewMethod("sliceAddress", "sliceAddress", Function, "", false, false, []Argument{{"inputs", AddressArr, false}}, nil),
+ "sliceMultiAddress": NewMethod("sliceMultiAddress", "sliceMultiAddress", Function, "", false, false, []Argument{{"a", AddressArr, false}, {"b", AddressArr, false}}, nil),
+ "nestedArray": NewMethod("nestedArray", "nestedArray", Function, "", false, false, []Argument{{"a", Uint256ArrNested, false}, {"b", AddressArr, false}}, nil),
+ "nestedArray2": NewMethod("nestedArray2", "nestedArray2", Function, "", false, false, []Argument{{"a", Uint8ArrNested, false}}, nil),
+ "nestedSlice": NewMethod("nestedSlice", "nestedSlice", Function, "", false, false, []Argument{{"a", Uint8SliceNested, false}}, nil),
+ "receive": NewMethod("receive", "receive", Function, "payable", false, true, []Argument{{"memo", Bytes, false}}, []Argument{}),
+ "fixedArrStr": NewMethod("fixedArrStr", "fixedArrStr", Function, "view", false, false, []Argument{{"str", String, false}, {"fixedArr", Uint256Arr2, false}}, nil),
+ "fixedArrBytes": NewMethod("fixedArrBytes", "fixedArrBytes", Function, "view", false, false, []Argument{{"bytes", Bytes, false}, {"fixedArr", Uint256Arr2, false}}, nil),
+ "mixedArrStr": NewMethod("mixedArrStr", "mixedArrStr", Function, "view", false, false, []Argument{{"str", String, false}, {"fixedArr", Uint256Arr2, false}, {"dynArr", Uint256Arr, false}}, nil),
+ "doubleFixedArrStr": NewMethod("doubleFixedArrStr", "doubleFixedArrStr", Function, "view", false, false, []Argument{{"str", String, false}, {"fixedArr1", Uint256Arr2, false}, {"fixedArr2", Uint256Arr3, false}}, nil),
+ "multipleMixedArrStr": NewMethod("multipleMixedArrStr", "multipleMixedArrStr", Function, "view", false, false, []Argument{{"str", String, false}, {"fixedArr1", Uint256Arr2, false}, {"dynArr", Uint256Arr, false}, {"fixedArr2", Uint256Arr3, false}}, nil),
+ "overloadedNames": NewMethod("overloadedNames", "overloadedNames", Function, "view", false, false, []Argument{{"f", TupleF, false}}, nil),
+}
+
+func TestReader(t *testing.T) {
+ abi := ABI{
+ Methods: methods,
+ }
+
+ exp, err := JSON(strings.NewReader(jsondata))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ for name, expM := range exp.Methods {
+ gotM, exist := abi.Methods[name]
+ if !exist {
+ t.Errorf("Missing expected method %v", name)
+ }
+ if !reflect.DeepEqual(gotM, expM) {
+ t.Errorf("\nGot abi method: \n%v\ndoes not match expected method\n%v", gotM, expM)
+ }
+ }
+
+ for name, gotM := range abi.Methods {
+ expM, exist := exp.Methods[name]
+ if !exist {
+ t.Errorf("Found extra method %v", name)
+ }
+ if !reflect.DeepEqual(gotM, expM) {
+ t.Errorf("\nGot abi method: \n%v\ndoes not match expected method\n%v", gotM, expM)
+ }
+ }
+}
+
+func TestInvalidABI(t *testing.T) {
+ json := `[{ "type" : "function", "name" : "", "constant" : fals }]`
+ _, err := JSON(strings.NewReader(json))
+ if err == nil {
+ t.Fatal("invalid json should produce error")
+ }
+ json2 := `[{ "type" : "function", "name" : "send", "constant" : false, "inputs" : [ { "name" : "amount", "typ" : "uint256" } ] }]`
+ _, err = JSON(strings.NewReader(json2))
+ if err == nil {
+ t.Fatal("invalid json should produce error")
+ }
+}
+
+// TestConstructor tests a constructor function.
+// The test is based on the following contract:
+// contract TestConstructor {
+// constructor(uint256 a, uint256 b) public{}
+// }
+func TestConstructor(t *testing.T) {
+ json := `[{ "inputs": [{"internalType": "uint256","name": "a","type": "uint256" },{ "internalType": "uint256","name": "b","type": "uint256"}],"stateMutability": "nonpayable","type": "constructor"}]`
+ method := NewMethod("", "", Constructor, "nonpayable", false, false, []Argument{{"a", Uint256, false}, {"b", Uint256, false}}, nil)
+ // Test from JSON
+ abi, err := JSON(strings.NewReader(json))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !reflect.DeepEqual(abi.Constructor, method) {
+ t.Error("Missing expected constructor")
+ }
+ // Test pack/unpack
+ packed, err := abi.Pack("", big.NewInt(1), big.NewInt(2))
+ if err != nil {
+ t.Error(err)
+ }
+ unpacked, err := abi.Constructor.Inputs.Unpack(packed)
+ if err != nil {
+ t.Error(err)
+ }
+
+ if !reflect.DeepEqual(unpacked[0], big.NewInt(1)) {
+ t.Error("Unable to pack/unpack from constructor")
+ }
+ if !reflect.DeepEqual(unpacked[1], big.NewInt(2)) {
+ t.Error("Unable to pack/unpack from constructor")
+ }
+}
+
+func TestTestNumbers(t *testing.T) {
+ abi, err := JSON(strings.NewReader(jsondata))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if _, err := abi.Pack("balance"); err != nil {
+ t.Error(err)
+ }
+
+ if _, err := abi.Pack("balance", 1); err == nil {
+ t.Error("expected error for balance(1)")
+ }
+
+ if _, err := abi.Pack("doesntexist", nil); err == nil {
+ t.Errorf("doesntexist shouldn't exist")
+ }
+
+ if _, err := abi.Pack("doesntexist", 1); err == nil {
+ t.Errorf("doesntexist(1) shouldn't exist")
+ }
+
+ if _, err := abi.Pack("send", big.NewInt(1000)); err != nil {
+ t.Error(err)
+ }
+
+ i := new(int)
+ *i = 1000
+ if _, err := abi.Pack("send", i); err == nil {
+ t.Errorf("expected send( ptr ) to throw, requires *big.Int instead of *int")
+ }
+
+ if _, err := abi.Pack("test", uint32(1000)); err != nil {
+ t.Error(err)
+ }
+}
+
+func TestMethodSignature(t *testing.T) {
+ m := NewMethod("foo", "foo", Function, "", false, false, []Argument{{"bar", String, false}, {"baz", String, false}}, nil)
+ exp := "foo(string,string)"
+ if m.Sig != exp {
+ t.Error("signature mismatch", exp, "!=", m.Sig)
+ }
+
+ idexp := crypto.Keccak256([]byte(exp))[:4]
+ if !bytes.Equal(m.ID, idexp) {
+ t.Errorf("expected ids to match %x != %x", m.ID, idexp)
+ }
+
+ m = NewMethod("foo", "foo", Function, "", false, false, []Argument{{"bar", Uint256, false}}, nil)
+ exp = "foo(uint256)"
+ if m.Sig != exp {
+ t.Error("signature mismatch", exp, "!=", m.Sig)
+ }
+
+ // Method with tuple arguments
+ s, _ := NewType("tuple", "", []ArgumentMarshaling{
+ {Name: "a", Type: "int256"},
+ {Name: "b", Type: "int256[]"},
+ {Name: "c", Type: "tuple[]", Components: []ArgumentMarshaling{
+ {Name: "x", Type: "int256"},
+ {Name: "y", Type: "int256"},
+ }},
+ {Name: "d", Type: "tuple[2]", Components: []ArgumentMarshaling{
+ {Name: "x", Type: "int256"},
+ {Name: "y", Type: "int256"},
+ }},
+ })
+ m = NewMethod("foo", "foo", Function, "", false, false, []Argument{{"s", s, false}, {"bar", String, false}}, nil)
+ exp = "foo((int256,int256[],(int256,int256)[],(int256,int256)[2]),string)"
+ if m.Sig != exp {
+ t.Error("signature mismatch", exp, "!=", m.Sig)
+ }
+}
+
+func TestOverloadedMethodSignature(t *testing.T) {
+ json := `[{"constant":true,"inputs":[{"name":"i","type":"uint256"},{"name":"j","type":"uint256"}],"name":"foo","outputs":[],"payable":false,"stateMutability":"pure","type":"function"},{"constant":true,"inputs":[{"name":"i","type":"uint256"}],"name":"foo","outputs":[],"payable":false,"stateMutability":"pure","type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"i","type":"uint256"}],"name":"bar","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"i","type":"uint256"},{"indexed":false,"name":"j","type":"uint256"}],"name":"bar","type":"event"}]`
+ abi, err := JSON(strings.NewReader(json))
+ if err != nil {
+ t.Fatal(err)
+ }
+ check := func(name string, expect string, method bool) {
+ if method {
+ if abi.Methods[name].Sig != expect {
+ t.Fatalf("The signature of overloaded method mismatch, want %s, have %s", expect, abi.Methods[name].Sig)
+ }
+ } else {
+ if abi.Events[name].Sig != expect {
+ t.Fatalf("The signature of overloaded event mismatch, want %s, have %s", expect, abi.Events[name].Sig)
+ }
+ }
+ }
+ check("foo", "foo(uint256,uint256)", true)
+ check("foo0", "foo(uint256)", true)
+ check("bar", "bar(uint256)", false)
+ check("bar0", "bar(uint256,uint256)", false)
+}
+
+func TestCustomErrors(t *testing.T) {
+ json := `[{ "inputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ],"name": "MyError", "type": "error"} ]`
+ abi, err := JSON(strings.NewReader(json))
+ if err != nil {
+ t.Fatal(err)
+ }
+ check := func(name string, expect string) {
+ if abi.Errors[name].Sig != expect {
+ t.Fatalf("The signature of overloaded method mismatch, want %s, have %s", expect, abi.Methods[name].Sig)
+ }
+ }
+ check("MyError", "MyError(uint256)")
+}
+
+func TestMultiPack(t *testing.T) {
+ abi, err := JSON(strings.NewReader(jsondata))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ sig := crypto.Keccak256([]byte("bar(uint32,uint16)"))[:4]
+ sig = append(sig, make([]byte, 64)...)
+ sig[35] = 10
+ sig[67] = 11
+
+ packed, err := abi.Pack("bar", uint32(10), uint16(11))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !bytes.Equal(packed, sig) {
+ t.Errorf("expected %x got %x", sig, packed)
+ }
+}
+
+func ExampleJSON() {
+ const definition = `[{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"isBar","outputs":[{"name":"","type":"bool"}],"type":"function"}]`
+
+ abi, err := JSON(strings.NewReader(definition))
+ if err != nil {
+ panic(err)
+ }
+ out, err := abi.Pack("isBar", common.HexToAddress("01"))
+ if err != nil {
+ panic(err)
+ }
+
+ fmt.Printf("%x\n", out)
+ // Output:
+ // 1f2c40920000000000000000000000000000000000000000000000000000000000000001
+}
+
+func TestInputVariableInputLength(t *testing.T) {
+ const definition = `[
+ { "type" : "function", "name" : "strOne", "constant" : true, "inputs" : [ { "name" : "str", "type" : "string" } ] },
+ { "type" : "function", "name" : "bytesOne", "constant" : true, "inputs" : [ { "name" : "str", "type" : "bytes" } ] },
+ { "type" : "function", "name" : "strTwo", "constant" : true, "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "str1", "type" : "string" } ] }
+ ]`
+
+ abi, err := JSON(strings.NewReader(definition))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ // test one string
+ strin := "hello world"
+ strpack, err := abi.Pack("strOne", strin)
+ if err != nil {
+ t.Error(err)
+ }
+
+ offset := make([]byte, 32)
+ offset[31] = 32
+ length := make([]byte, 32)
+ length[31] = byte(len(strin))
+ value := common.RightPadBytes([]byte(strin), 32)
+ exp := append(offset, append(length, value...)...)
+
+ // ignore first 4 bytes of the output. This is the function identifier
+ strpack = strpack[4:]
+ if !bytes.Equal(strpack, exp) {
+ t.Errorf("expected %x, got %x\n", exp, strpack)
+ }
+
+ // test one bytes
+ btspack, err := abi.Pack("bytesOne", []byte(strin))
+ if err != nil {
+ t.Error(err)
+ }
+ // ignore first 4 bytes of the output. This is the function identifier
+ btspack = btspack[4:]
+ if !bytes.Equal(btspack, exp) {
+ t.Errorf("expected %x, got %x\n", exp, btspack)
+ }
+
+ // test two strings
+ str1 := "hello"
+ str2 := "world"
+ str2pack, err := abi.Pack("strTwo", str1, str2)
+ if err != nil {
+ t.Error(err)
+ }
+
+ offset1 := make([]byte, 32)
+ offset1[31] = 64
+ length1 := make([]byte, 32)
+ length1[31] = byte(len(str1))
+ value1 := common.RightPadBytes([]byte(str1), 32)
+
+ offset2 := make([]byte, 32)
+ offset2[31] = 128
+ length2 := make([]byte, 32)
+ length2[31] = byte(len(str2))
+ value2 := common.RightPadBytes([]byte(str2), 32)
+
+ exp2 := append(offset1, offset2...)
+ exp2 = append(exp2, append(length1, value1...)...)
+ exp2 = append(exp2, append(length2, value2...)...)
+
+ // ignore first 4 bytes of the output. This is the function identifier
+ str2pack = str2pack[4:]
+ if !bytes.Equal(str2pack, exp2) {
+ t.Errorf("expected %x, got %x\n", exp, str2pack)
+ }
+
+ // test two strings, first > 32, second < 32
+ str1 = strings.Repeat("a", 33)
+ str2pack, err = abi.Pack("strTwo", str1, str2)
+ if err != nil {
+ t.Error(err)
+ }
+
+ offset1 = make([]byte, 32)
+ offset1[31] = 64
+ length1 = make([]byte, 32)
+ length1[31] = byte(len(str1))
+ value1 = common.RightPadBytes([]byte(str1), 64)
+ offset2[31] = 160
+
+ exp2 = append(offset1, offset2...)
+ exp2 = append(exp2, append(length1, value1...)...)
+ exp2 = append(exp2, append(length2, value2...)...)
+
+ // ignore first 4 bytes of the output. This is the function identifier
+ str2pack = str2pack[4:]
+ if !bytes.Equal(str2pack, exp2) {
+ t.Errorf("expected %x, got %x\n", exp, str2pack)
+ }
+
+ // test two strings, first > 32, second >32
+ str1 = strings.Repeat("a", 33)
+ str2 = strings.Repeat("a", 33)
+ str2pack, err = abi.Pack("strTwo", str1, str2)
+ if err != nil {
+ t.Error(err)
+ }
+
+ offset1 = make([]byte, 32)
+ offset1[31] = 64
+ length1 = make([]byte, 32)
+ length1[31] = byte(len(str1))
+ value1 = common.RightPadBytes([]byte(str1), 64)
+
+ offset2 = make([]byte, 32)
+ offset2[31] = 160
+ length2 = make([]byte, 32)
+ length2[31] = byte(len(str2))
+ value2 = common.RightPadBytes([]byte(str2), 64)
+
+ exp2 = append(offset1, offset2...)
+ exp2 = append(exp2, append(length1, value1...)...)
+ exp2 = append(exp2, append(length2, value2...)...)
+
+ // ignore first 4 bytes of the output. This is the function identifier
+ str2pack = str2pack[4:]
+ if !bytes.Equal(str2pack, exp2) {
+ t.Errorf("expected %x, got %x\n", exp, str2pack)
+ }
+}
+
+func TestInputFixedArrayAndVariableInputLength(t *testing.T) {
+ abi, err := JSON(strings.NewReader(jsondata))
+ if err != nil {
+ t.Error(err)
+ }
+
+ // test string, fixed array uint256[2]
+ strin := "hello world"
+ arrin := [2]*big.Int{big.NewInt(1), big.NewInt(2)}
+ fixedArrStrPack, err := abi.Pack("fixedArrStr", strin, arrin)
+ if err != nil {
+ t.Error(err)
+ }
+
+ // generate expected output
+ offset := make([]byte, 32)
+ offset[31] = 96
+ length := make([]byte, 32)
+ length[31] = byte(len(strin))
+ strvalue := common.RightPadBytes([]byte(strin), 32)
+ arrinvalue1 := common.LeftPadBytes(arrin[0].Bytes(), 32)
+ arrinvalue2 := common.LeftPadBytes(arrin[1].Bytes(), 32)
+ exp := append(offset, arrinvalue1...)
+ exp = append(exp, arrinvalue2...)
+ exp = append(exp, append(length, strvalue...)...)
+
+ // ignore first 4 bytes of the output. This is the function identifier
+ fixedArrStrPack = fixedArrStrPack[4:]
+ if !bytes.Equal(fixedArrStrPack, exp) {
+ t.Errorf("expected %x, got %x\n", exp, fixedArrStrPack)
+ }
+
+ // test byte array, fixed array uint256[2]
+ bytesin := []byte(strin)
+ arrin = [2]*big.Int{big.NewInt(1), big.NewInt(2)}
+ fixedArrBytesPack, err := abi.Pack("fixedArrBytes", bytesin, arrin)
+ if err != nil {
+ t.Error(err)
+ }
+
+ // generate expected output
+ offset = make([]byte, 32)
+ offset[31] = 96
+ length = make([]byte, 32)
+ length[31] = byte(len(strin))
+ strvalue = common.RightPadBytes([]byte(strin), 32)
+ arrinvalue1 = common.LeftPadBytes(arrin[0].Bytes(), 32)
+ arrinvalue2 = common.LeftPadBytes(arrin[1].Bytes(), 32)
+ exp = append(offset, arrinvalue1...)
+ exp = append(exp, arrinvalue2...)
+ exp = append(exp, append(length, strvalue...)...)
+
+ // ignore first 4 bytes of the output. This is the function identifier
+ fixedArrBytesPack = fixedArrBytesPack[4:]
+ if !bytes.Equal(fixedArrBytesPack, exp) {
+ t.Errorf("expected %x, got %x\n", exp, fixedArrBytesPack)
+ }
+
+ // test string, fixed array uint256[2], dynamic array uint256[]
+ strin = "hello world"
+ fixedarrin := [2]*big.Int{big.NewInt(1), big.NewInt(2)}
+ dynarrin := []*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)}
+ mixedArrStrPack, err := abi.Pack("mixedArrStr", strin, fixedarrin, dynarrin)
+ if err != nil {
+ t.Error(err)
+ }
+
+ // generate expected output
+ stroffset := make([]byte, 32)
+ stroffset[31] = 128
+ strlength := make([]byte, 32)
+ strlength[31] = byte(len(strin))
+ strvalue = common.RightPadBytes([]byte(strin), 32)
+ fixedarrinvalue1 := common.LeftPadBytes(fixedarrin[0].Bytes(), 32)
+ fixedarrinvalue2 := common.LeftPadBytes(fixedarrin[1].Bytes(), 32)
+ dynarroffset := make([]byte, 32)
+ dynarroffset[31] = byte(160 + ((len(strin)/32)+1)*32)
+ dynarrlength := make([]byte, 32)
+ dynarrlength[31] = byte(len(dynarrin))
+ dynarrinvalue1 := common.LeftPadBytes(dynarrin[0].Bytes(), 32)
+ dynarrinvalue2 := common.LeftPadBytes(dynarrin[1].Bytes(), 32)
+ dynarrinvalue3 := common.LeftPadBytes(dynarrin[2].Bytes(), 32)
+ exp = append(stroffset, fixedarrinvalue1...)
+ exp = append(exp, fixedarrinvalue2...)
+ exp = append(exp, dynarroffset...)
+ exp = append(exp, append(strlength, strvalue...)...)
+ dynarrarg := append(dynarrlength, dynarrinvalue1...)
+ dynarrarg = append(dynarrarg, dynarrinvalue2...)
+ dynarrarg = append(dynarrarg, dynarrinvalue3...)
+ exp = append(exp, dynarrarg...)
+
+ // ignore first 4 bytes of the output. This is the function identifier
+ mixedArrStrPack = mixedArrStrPack[4:]
+ if !bytes.Equal(mixedArrStrPack, exp) {
+ t.Errorf("expected %x, got %x\n", exp, mixedArrStrPack)
+ }
+
+ // test string, fixed array uint256[2], fixed array uint256[3]
+ strin = "hello world"
+ fixedarrin1 := [2]*big.Int{big.NewInt(1), big.NewInt(2)}
+ fixedarrin2 := [3]*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)}
+ doubleFixedArrStrPack, err := abi.Pack("doubleFixedArrStr", strin, fixedarrin1, fixedarrin2)
+ if err != nil {
+ t.Error(err)
+ }
+
+ // generate expected output
+ stroffset = make([]byte, 32)
+ stroffset[31] = 192
+ strlength = make([]byte, 32)
+ strlength[31] = byte(len(strin))
+ strvalue = common.RightPadBytes([]byte(strin), 32)
+ fixedarrin1value1 := common.LeftPadBytes(fixedarrin1[0].Bytes(), 32)
+ fixedarrin1value2 := common.LeftPadBytes(fixedarrin1[1].Bytes(), 32)
+ fixedarrin2value1 := common.LeftPadBytes(fixedarrin2[0].Bytes(), 32)
+ fixedarrin2value2 := common.LeftPadBytes(fixedarrin2[1].Bytes(), 32)
+ fixedarrin2value3 := common.LeftPadBytes(fixedarrin2[2].Bytes(), 32)
+ exp = append(stroffset, fixedarrin1value1...)
+ exp = append(exp, fixedarrin1value2...)
+ exp = append(exp, fixedarrin2value1...)
+ exp = append(exp, fixedarrin2value2...)
+ exp = append(exp, fixedarrin2value3...)
+ exp = append(exp, append(strlength, strvalue...)...)
+
+ // ignore first 4 bytes of the output. This is the function identifier
+ doubleFixedArrStrPack = doubleFixedArrStrPack[4:]
+ if !bytes.Equal(doubleFixedArrStrPack, exp) {
+ t.Errorf("expected %x, got %x\n", exp, doubleFixedArrStrPack)
+ }
+
+ // test string, fixed array uint256[2], dynamic array uint256[], fixed array uint256[3]
+ strin = "hello world"
+ fixedarrin1 = [2]*big.Int{big.NewInt(1), big.NewInt(2)}
+ dynarrin = []*big.Int{big.NewInt(1), big.NewInt(2)}
+ fixedarrin2 = [3]*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)}
+ multipleMixedArrStrPack, err := abi.Pack("multipleMixedArrStr", strin, fixedarrin1, dynarrin, fixedarrin2)
+ if err != nil {
+ t.Error(err)
+ }
+
+ // generate expected output
+ stroffset = make([]byte, 32)
+ stroffset[31] = 224
+ strlength = make([]byte, 32)
+ strlength[31] = byte(len(strin))
+ strvalue = common.RightPadBytes([]byte(strin), 32)
+ fixedarrin1value1 = common.LeftPadBytes(fixedarrin1[0].Bytes(), 32)
+ fixedarrin1value2 = common.LeftPadBytes(fixedarrin1[1].Bytes(), 32)
+ dynarroffset = math.U256Bytes(big.NewInt(int64(256 + ((len(strin)/32)+1)*32)))
+ dynarrlength = make([]byte, 32)
+ dynarrlength[31] = byte(len(dynarrin))
+ dynarrinvalue1 = common.LeftPadBytes(dynarrin[0].Bytes(), 32)
+ dynarrinvalue2 = common.LeftPadBytes(dynarrin[1].Bytes(), 32)
+ fixedarrin2value1 = common.LeftPadBytes(fixedarrin2[0].Bytes(), 32)
+ fixedarrin2value2 = common.LeftPadBytes(fixedarrin2[1].Bytes(), 32)
+ fixedarrin2value3 = common.LeftPadBytes(fixedarrin2[2].Bytes(), 32)
+ exp = append(stroffset, fixedarrin1value1...)
+ exp = append(exp, fixedarrin1value2...)
+ exp = append(exp, dynarroffset...)
+ exp = append(exp, fixedarrin2value1...)
+ exp = append(exp, fixedarrin2value2...)
+ exp = append(exp, fixedarrin2value3...)
+ exp = append(exp, append(strlength, strvalue...)...)
+ dynarrarg = append(dynarrlength, dynarrinvalue1...)
+ dynarrarg = append(dynarrarg, dynarrinvalue2...)
+ exp = append(exp, dynarrarg...)
+
+ // ignore first 4 bytes of the output. This is the function identifier
+ multipleMixedArrStrPack = multipleMixedArrStrPack[4:]
+ if !bytes.Equal(multipleMixedArrStrPack, exp) {
+ t.Errorf("expected %x, got %x\n", exp, multipleMixedArrStrPack)
+ }
+}
+
+func TestDefaultFunctionParsing(t *testing.T) {
+ const definition = `[{ "name" : "balance", "type" : "function" }]`
+
+ abi, err := JSON(strings.NewReader(definition))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if _, ok := abi.Methods["balance"]; !ok {
+ t.Error("expected 'balance' to be present")
+ }
+}
+
+func TestBareEvents(t *testing.T) {
+ const definition = `[
+ { "type" : "event", "name" : "balance" },
+ { "type" : "event", "name" : "anon", "anonymous" : true},
+ { "type" : "event", "name" : "args", "inputs" : [{ "indexed":false, "name":"arg0", "type":"uint256" }, { "indexed":true, "name":"arg1", "type":"address" }] },
+ { "type" : "event", "name" : "tuple", "inputs" : [{ "indexed":false, "name":"t", "type":"tuple", "components":[{"name":"a", "type":"uint256"}] }, { "indexed":true, "name":"arg1", "type":"address" }] }
+ ]`
+
+ tuple, _ := NewType("tuple", "", []ArgumentMarshaling{{Name: "a", Type: "uint256"}})
+
+ expectedEvents := map[string]struct {
+ Anonymous bool
+ Args []Argument
+ }{
+ "balance": {false, nil},
+ "anon": {true, nil},
+ "args": {false, []Argument{
+ {Name: "arg0", Type: Uint256, Indexed: false},
+ {Name: "arg1", Type: Address, Indexed: true},
+ }},
+ "tuple": {false, []Argument{
+ {Name: "t", Type: tuple, Indexed: false},
+ {Name: "arg1", Type: Address, Indexed: true},
+ }},
+ }
+
+ abi, err := JSON(strings.NewReader(definition))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if len(abi.Events) != len(expectedEvents) {
+ t.Fatalf("invalid number of events after parsing, want %d, got %d", len(expectedEvents), len(abi.Events))
+ }
+
+ for name, exp := range expectedEvents {
+ got, ok := abi.Events[name]
+ if !ok {
+ t.Errorf("could not found event %s", name)
+ continue
+ }
+ if got.Anonymous != exp.Anonymous {
+ t.Errorf("invalid anonymous indication for event %s, want %v, got %v", name, exp.Anonymous, got.Anonymous)
+ }
+ if len(got.Inputs) != len(exp.Args) {
+ t.Errorf("invalid number of args, want %d, got %d", len(exp.Args), len(got.Inputs))
+ continue
+ }
+ for i, arg := range exp.Args {
+ if arg.Name != got.Inputs[i].Name {
+ t.Errorf("events[%s].Input[%d] has an invalid name, want %s, got %s", name, i, arg.Name, got.Inputs[i].Name)
+ }
+ if arg.Indexed != got.Inputs[i].Indexed {
+ t.Errorf("events[%s].Input[%d] has an invalid indexed indication, want %v, got %v", name, i, arg.Indexed, got.Inputs[i].Indexed)
+ }
+ if arg.Type.T != got.Inputs[i].Type.T {
+ t.Errorf("events[%s].Input[%d] has an invalid type, want %x, got %x", name, i, arg.Type.T, got.Inputs[i].Type.T)
+ }
+ }
+ }
+}
+
+// TestUnpackEvent is based on this contract:
+// contract T {
+// event received(address sender, uint amount, bytes memo);
+// event receivedAddr(address sender);
+// function receive(bytes memo) external payable {
+// received(msg.sender, msg.value, memo);
+// receivedAddr(msg.sender);
+// }
+// }
+// When receive("X") is called with sender 0x00... and value 1, it produces this tx receipt:
+// receipt{status=1 cgas=23949 bloom=00000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000040200000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 logs=[log: b6818c8064f645cd82d99b59a1a267d6d61117ef [75fd880d39c1daf53b6547ab6cb59451fc6452d27caa90e5b6649dd8293b9eed] 000000000000000000000000376c47978271565f56deb45495afa69e59c16ab200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158 9ae378b6d4409eada347a5dc0c180f186cb62dc68fcc0f043425eb917335aa28 0 95d429d309bb9d753954195fe2d69bd140b4ae731b9b5b605c34323de162cf00 0]}
+func TestUnpackEvent(t *testing.T) {
+ const abiJSON = `[{"constant":false,"inputs":[{"name":"memo","type":"bytes"}],"name":"receive","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"}],"name":"receivedAddr","type":"event"}]`
+ abi, err := JSON(strings.NewReader(abiJSON))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ const hexdata = `000000000000000000000000376c47978271565f56deb45495afa69e59c16ab200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158`
+ data, err := hex.DecodeString(hexdata)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(data)%32 == 0 {
+ t.Errorf("len(data) is %d, want a non-multiple of 32", len(data))
+ }
+
+ type ReceivedEvent struct {
+ Sender common.Address
+ Amount *big.Int
+ Memo []byte
+ }
+ var ev ReceivedEvent
+
+ err = abi.UnpackIntoInterface(&ev, "received", data)
+ if err != nil {
+ t.Error(err)
+ }
+
+ type ReceivedAddrEvent struct {
+ Sender common.Address
+ }
+ var receivedAddrEv ReceivedAddrEvent
+ err = abi.UnpackIntoInterface(&receivedAddrEv, "receivedAddr", data)
+ if err != nil {
+ t.Error(err)
+ }
+}
+
+func TestUnpackEventIntoMap(t *testing.T) {
+ const abiJSON = `[{"constant":false,"inputs":[{"name":"memo","type":"bytes"}],"name":"receive","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"}],"name":"receivedAddr","type":"event"}]`
+ abi, err := JSON(strings.NewReader(abiJSON))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ const hexdata = `000000000000000000000000376c47978271565f56deb45495afa69e59c16ab200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158`
+ data, err := hex.DecodeString(hexdata)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(data)%32 == 0 {
+ t.Errorf("len(data) is %d, want a non-multiple of 32", len(data))
+ }
+
+ receivedMap := map[string]interface{}{}
+ expectedReceivedMap := map[string]interface{}{
+ "sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"),
+ "amount": big.NewInt(1),
+ "memo": []byte{88},
+ }
+ if err := abi.UnpackIntoMap(receivedMap, "received", data); err != nil {
+ t.Error(err)
+ }
+ if len(receivedMap) != 3 {
+ t.Error("unpacked `received` map expected to have length 3")
+ }
+ if receivedMap["sender"] != expectedReceivedMap["sender"] {
+ t.Error("unpacked `received` map does not match expected map")
+ }
+ if receivedMap["amount"].(*big.Int).Cmp(expectedReceivedMap["amount"].(*big.Int)) != 0 {
+ t.Error("unpacked `received` map does not match expected map")
+ }
+ if !bytes.Equal(receivedMap["memo"].([]byte), expectedReceivedMap["memo"].([]byte)) {
+ t.Error("unpacked `received` map does not match expected map")
+ }
+
+ receivedAddrMap := map[string]interface{}{}
+ if err = abi.UnpackIntoMap(receivedAddrMap, "receivedAddr", data); err != nil {
+ t.Error(err)
+ }
+ if len(receivedAddrMap) != 1 {
+ t.Error("unpacked `receivedAddr` map expected to have length 1")
+ }
+ if receivedAddrMap["sender"] != expectedReceivedMap["sender"] {
+ t.Error("unpacked `receivedAddr` map does not match expected map")
+ }
+}
+
+func TestUnpackMethodIntoMap(t *testing.T) {
+ const abiJSON = `[{"constant":false,"inputs":[{"name":"memo","type":"bytes"}],"name":"receive","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[],"name":"send","outputs":[{"name":"amount","type":"uint256"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"name":"addr","type":"address"}],"name":"get","outputs":[{"name":"hash","type":"bytes"}],"payable":true,"stateMutability":"payable","type":"function"}]`
+ abi, err := JSON(strings.NewReader(abiJSON))
+ if err != nil {
+ t.Fatal(err)
+ }
+ const hexdata = `00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000015800000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000158000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000001580000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000015800000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000158`
+ data, err := hex.DecodeString(hexdata)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(data)%32 != 0 {
+ t.Errorf("len(data) is %d, want a multiple of 32", len(data))
+ }
+
+ // Tests a method with no outputs
+ receiveMap := map[string]interface{}{}
+ if err = abi.UnpackIntoMap(receiveMap, "receive", data); err != nil {
+ t.Error(err)
+ }
+ if len(receiveMap) > 0 {
+ t.Error("unpacked `receive` map expected to have length 0")
+ }
+
+ // Tests a method with only outputs
+ sendMap := map[string]interface{}{}
+ if err = abi.UnpackIntoMap(sendMap, "send", data); err != nil {
+ t.Error(err)
+ }
+ if len(sendMap) != 1 {
+ t.Error("unpacked `send` map expected to have length 1")
+ }
+ if sendMap["amount"].(*big.Int).Cmp(big.NewInt(1)) != 0 {
+ t.Error("unpacked `send` map expected `amount` value of 1")
+ }
+
+ // Tests a method with outputs and inputs
+ getMap := map[string]interface{}{}
+ if err = abi.UnpackIntoMap(getMap, "get", data); err != nil {
+ t.Error(err)
+ }
+ if len(getMap) != 1 {
+ t.Error("unpacked `get` map expected to have length 1")
+ }
+ expectedBytes := []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 88, 0}
+ if !bytes.Equal(getMap["hash"].([]byte), expectedBytes) {
+ t.Errorf("unpacked `get` map expected `hash` value of %v", expectedBytes)
+ }
+}
+
+func TestUnpackIntoMapNamingConflict(t *testing.T) {
+ // Two methods have the same name
+ var abiJSON = `[{"constant":false,"inputs":[{"name":"memo","type":"bytes"}],"name":"get","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[],"name":"send","outputs":[{"name":"amount","type":"uint256"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"name":"addr","type":"address"}],"name":"get","outputs":[{"name":"hash","type":"bytes"}],"payable":true,"stateMutability":"payable","type":"function"}]`
+ abi, err := JSON(strings.NewReader(abiJSON))
+ if err != nil {
+ t.Fatal(err)
+ }
+ var hexdata = `00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158`
+ data, err := hex.DecodeString(hexdata)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(data)%32 == 0 {
+ t.Errorf("len(data) is %d, want a non-multiple of 32", len(data))
+ }
+ getMap := map[string]interface{}{}
+ if err = abi.UnpackIntoMap(getMap, "get", data); err == nil {
+ t.Error("naming conflict between two methods; error expected")
+ }
+
+ // Two events have the same name
+ abiJSON = `[{"constant":false,"inputs":[{"name":"memo","type":"bytes"}],"name":"receive","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"}],"name":"received","type":"event"}]`
+ abi, err = JSON(strings.NewReader(abiJSON))
+ if err != nil {
+ t.Fatal(err)
+ }
+ hexdata = `000000000000000000000000376c47978271565f56deb45495afa69e59c16ab200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158`
+ data, err = hex.DecodeString(hexdata)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(data)%32 == 0 {
+ t.Errorf("len(data) is %d, want a non-multiple of 32", len(data))
+ }
+ receivedMap := map[string]interface{}{}
+ if err = abi.UnpackIntoMap(receivedMap, "received", data); err != nil {
+ t.Error("naming conflict between two events; no error expected")
+ }
+
+ // Method and event have the same name
+ abiJSON = `[{"constant":false,"inputs":[{"name":"memo","type":"bytes"}],"name":"received","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"}],"name":"receivedAddr","type":"event"}]`
+ abi, err = JSON(strings.NewReader(abiJSON))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(data)%32 == 0 {
+ t.Errorf("len(data) is %d, want a non-multiple of 32", len(data))
+ }
+ if err = abi.UnpackIntoMap(receivedMap, "received", data); err == nil {
+ t.Error("naming conflict between an event and a method; error expected")
+ }
+
+ // Conflict is case sensitive
+ abiJSON = `[{"constant":false,"inputs":[{"name":"memo","type":"bytes"}],"name":"received","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"Received","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"}],"name":"receivedAddr","type":"event"}]`
+ abi, err = JSON(strings.NewReader(abiJSON))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(data)%32 == 0 {
+ t.Errorf("len(data) is %d, want a non-multiple of 32", len(data))
+ }
+ expectedReceivedMap := map[string]interface{}{
+ "sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"),
+ "amount": big.NewInt(1),
+ "memo": []byte{88},
+ }
+ if err = abi.UnpackIntoMap(receivedMap, "Received", data); err != nil {
+ t.Error(err)
+ }
+ if len(receivedMap) != 3 {
+ t.Error("unpacked `received` map expected to have length 3")
+ }
+ if receivedMap["sender"] != expectedReceivedMap["sender"] {
+ t.Error("unpacked `received` map does not match expected map")
+ }
+ if receivedMap["amount"].(*big.Int).Cmp(expectedReceivedMap["amount"].(*big.Int)) != 0 {
+ t.Error("unpacked `received` map does not match expected map")
+ }
+ if !bytes.Equal(receivedMap["memo"].([]byte), expectedReceivedMap["memo"].([]byte)) {
+ t.Error("unpacked `received` map does not match expected map")
+ }
+}
+
+func TestABI_MethodById(t *testing.T) {
+ abi, err := JSON(strings.NewReader(jsondata))
+ if err != nil {
+ t.Fatal(err)
+ }
+ for name, m := range abi.Methods {
+ a := fmt.Sprintf("%v", m)
+ m2, err := abi.MethodById(m.ID)
+ if err != nil {
+ t.Fatalf("Failed to look up ABI method: %v", err)
+ }
+ b := fmt.Sprintf("%v", m2)
+ if a != b {
+ t.Errorf("Method %v (id %x) not 'findable' by id in ABI", name, m.ID)
+ }
+ }
+ // test unsuccessful lookups
+ if _, err = abi.MethodById(crypto.Keccak256()); err == nil {
+ t.Error("Expected error: no method with this id")
+ }
+ // Also test empty
+ if _, err := abi.MethodById([]byte{0x00}); err == nil {
+ t.Errorf("Expected error, too short to decode data")
+ }
+ if _, err := abi.MethodById([]byte{}); err == nil {
+ t.Errorf("Expected error, too short to decode data")
+ }
+ if _, err := abi.MethodById(nil); err == nil {
+ t.Errorf("Expected error, nil is short to decode data")
+ }
+}
+
+func TestABI_EventById(t *testing.T) {
+ tests := []struct {
+ name string
+ json string
+ event string
+ }{
+ {
+ name: "",
+ json: `[
+ {"type":"event","name":"received","anonymous":false,"inputs":[
+ {"indexed":false,"name":"sender","type":"address"},
+ {"indexed":false,"name":"amount","type":"uint256"},
+ {"indexed":false,"name":"memo","type":"bytes"}
+ ]
+ }]`,
+ event: "received(address,uint256,bytes)",
+ }, {
+ name: "",
+ json: `[
+ { "constant": true, "inputs": [], "name": "name", "outputs": [ { "name": "", "type": "string" } ], "payable": false, "stateMutability": "view", "type": "function" },
+ { "constant": false, "inputs": [ { "name": "_spender", "type": "address" }, { "name": "_value", "type": "uint256" } ], "name": "approve", "outputs": [ { "name": "", "type": "bool" } ], "payable": false, "stateMutability": "nonpayable", "type": "function" },
+ { "constant": true, "inputs": [], "name": "totalSupply", "outputs": [ { "name": "", "type": "uint256" } ], "payable": false, "stateMutability": "view", "type": "function" },
+ { "constant": false, "inputs": [ { "name": "_from", "type": "address" }, { "name": "_to", "type": "address" }, { "name": "_value", "type": "uint256" } ], "name": "transferFrom", "outputs": [ { "name": "", "type": "bool" } ], "payable": false, "stateMutability": "nonpayable", "type": "function" },
+ { "constant": true, "inputs": [], "name": "decimals", "outputs": [ { "name": "", "type": "uint8" } ], "payable": false, "stateMutability": "view", "type": "function" },
+ { "constant": true, "inputs": [ { "name": "_owner", "type": "address" } ], "name": "balanceOf", "outputs": [ { "name": "balance", "type": "uint256" } ], "payable": false, "stateMutability": "view", "type": "function" },
+ { "constant": true, "inputs": [], "name": "symbol", "outputs": [ { "name": "", "type": "string" } ], "payable": false, "stateMutability": "view", "type": "function" },
+ { "constant": false, "inputs": [ { "name": "_to", "type": "address" }, { "name": "_value", "type": "uint256" } ], "name": "transfer", "outputs": [ { "name": "", "type": "bool" } ], "payable": false, "stateMutability": "nonpayable", "type": "function" },
+ { "constant": true, "inputs": [ { "name": "_owner", "type": "address" }, { "name": "_spender", "type": "address" } ], "name": "allowance", "outputs": [ { "name": "", "type": "uint256" } ], "payable": false, "stateMutability": "view", "type": "function" },
+ { "payable": true, "stateMutability": "payable", "type": "fallback" },
+ { "anonymous": false, "inputs": [ { "indexed": true, "name": "owner", "type": "address" }, { "indexed": true, "name": "spender", "type": "address" }, { "indexed": false, "name": "value", "type": "uint256" } ], "name": "Approval", "type": "event" },
+ { "anonymous": false, "inputs": [ { "indexed": true, "name": "from", "type": "address" }, { "indexed": true, "name": "to", "type": "address" }, { "indexed": false, "name": "value", "type": "uint256" } ], "name": "Transfer", "type": "event" }
+ ]`,
+ event: "Transfer(address,address,uint256)",
+ },
+ }
+
+ for testnum, test := range tests {
+ abi, err := JSON(strings.NewReader(test.json))
+ if err != nil {
+ t.Error(err)
+ }
+
+ topic := test.event
+ topicID := crypto.Keccak256Hash([]byte(topic))
+
+ event, err := abi.EventByID(topicID)
+ if err != nil {
+ t.Fatalf("Failed to look up ABI method: %v, test #%d", err, testnum)
+ }
+ if event == nil {
+ t.Errorf("We should find a event for topic %s, test #%d", topicID.Hex(), testnum)
+ } else if event.ID != topicID {
+ t.Errorf("Event id %s does not match topic %s, test #%d", event.ID.Hex(), topicID.Hex(), testnum)
+ }
+
+ unknowntopicID := crypto.Keccak256Hash([]byte("unknownEvent"))
+ unknownEvent, err := abi.EventByID(unknowntopicID)
+ if err == nil {
+ t.Errorf("EventByID should return an error if a topic is not found, test #%d", testnum)
+ }
+ if unknownEvent != nil {
+ t.Errorf("We should not find any event for topic %s, test #%d", unknowntopicID.Hex(), testnum)
+ }
+ }
+}
+
+// TestDoubleDuplicateMethodNames checks that if transfer0 already exists, there won't be a name
+// conflict and that the second transfer method will be renamed transfer1.
+func TestDoubleDuplicateMethodNames(t *testing.T) {
+ abiJSON := `[{"constant":false,"inputs":[{"name":"to","type":"address"},{"name":"value","type":"uint256"}],"name":"transfer","outputs":[{"name":"ok","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"to","type":"address"},{"name":"value","type":"uint256"},{"name":"data","type":"bytes"}],"name":"transfer0","outputs":[{"name":"ok","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"to","type":"address"},{"name":"value","type":"uint256"},{"name":"data","type":"bytes"},{"name":"customFallback","type":"string"}],"name":"transfer","outputs":[{"name":"ok","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"}]`
+ contractAbi, err := JSON(strings.NewReader(abiJSON))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, ok := contractAbi.Methods["transfer"]; !ok {
+ t.Fatalf("Could not find original method")
+ }
+ if _, ok := contractAbi.Methods["transfer0"]; !ok {
+ t.Fatalf("Could not find duplicate method")
+ }
+ if _, ok := contractAbi.Methods["transfer1"]; !ok {
+ t.Fatalf("Could not find duplicate method")
+ }
+ if _, ok := contractAbi.Methods["transfer2"]; ok {
+ t.Fatalf("Should not have found extra method")
+ }
+}
+
+// TestDoubleDuplicateEventNames checks that if send0 already exists, there won't be a name
+// conflict and that the second send event will be renamed send1.
+// The test runs the abi of the following contract.
+// contract DuplicateEvent {
+// event send(uint256 a);
+// event send0();
+// event send();
+// }
+func TestDoubleDuplicateEventNames(t *testing.T) {
+ abiJSON := `[{"anonymous": false,"inputs": [{"indexed": false,"internalType": "uint256","name": "a","type": "uint256"}],"name": "send","type": "event"},{"anonymous": false,"inputs": [],"name": "send0","type": "event"},{ "anonymous": false, "inputs": [],"name": "send","type": "event"}]`
+ contractAbi, err := JSON(strings.NewReader(abiJSON))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, ok := contractAbi.Events["send"]; !ok {
+ t.Fatalf("Could not find original event")
+ }
+ if _, ok := contractAbi.Events["send0"]; !ok {
+ t.Fatalf("Could not find duplicate event")
+ }
+ if _, ok := contractAbi.Events["send1"]; !ok {
+ t.Fatalf("Could not find duplicate event")
+ }
+ if _, ok := contractAbi.Events["send2"]; ok {
+ t.Fatalf("Should not have found extra event")
+ }
+}
+
+// TestUnnamedEventParam checks that an event with unnamed parameters is
+// correctly handled.
+// The test runs the abi of the following contract.
+// contract TestEvent {
+// event send(uint256, uint256);
+// }
+func TestUnnamedEventParam(t *testing.T) {
+ abiJSON := `[{ "anonymous": false, "inputs": [{ "indexed": false,"internalType": "uint256", "name": "","type": "uint256"},{"indexed": false,"internalType": "uint256","name": "","type": "uint256"}],"name": "send","type": "event"}]`
+ contractAbi, err := JSON(strings.NewReader(abiJSON))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ event, ok := contractAbi.Events["send"]
+ if !ok {
+ t.Fatalf("Could not find event")
+ }
+ if event.Inputs[0].Name != "arg0" {
+ t.Fatalf("Could not find input")
+ }
+ if event.Inputs[1].Name != "arg1" {
+ t.Fatalf("Could not find input")
+ }
+}
+
+func TestUnpackRevert(t *testing.T) {
+ t.Parallel()
+
+ var cases = []struct {
+ input string
+ expect string
+ expectErr error
+ }{
+ {"", "", errors.New("invalid data for unpacking")},
+ {"08c379a1", "", errors.New("invalid data for unpacking")},
+ {"08c379a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000d72657665727420726561736f6e00000000000000000000000000000000000000", "revert reason", nil},
+ }
+ for index, c := range cases {
+ t.Run(fmt.Sprintf("case %d", index), func(t *testing.T) {
+ got, err := UnpackRevert(common.Hex2Bytes(c.input))
+ if c.expectErr != nil {
+ if err == nil {
+ t.Fatalf("Expected non-nil error")
+ }
+ if err.Error() != c.expectErr.Error() {
+ t.Fatalf("Expected error mismatch, want %v, got %v", c.expectErr, err)
+ }
+ return
+ }
+ if c.expect != got {
+ t.Fatalf("Output mismatch, want %v, got %v", c.expect, got)
+ }
+ })
+ }
+}
diff --git a/abigen/accounts/abi/argument.go b/abigen/accounts/abi/argument.go
new file mode 100644
index 00000000..ba52d974
--- /dev/null
+++ b/abigen/accounts/abi/argument.go
@@ -0,0 +1,275 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package abi
+
+import (
+ "encoding/json"
+ "fmt"
+ "reflect"
+ "strings"
+)
+
+// Argument holds the name of the argument and the corresponding type.
+// Types are used when packing and testing arguments.
+type Argument struct {
+ Name string
+ Type Type
+ Indexed bool // indexed is only used by events
+ Offset int
+}
+
+type Arguments []Argument
+
+type ArgumentMarshaling struct {
+ Name string
+ Type string
+ InternalType string
+ Components []ArgumentMarshaling
+ Indexed bool
+ Offset int
+}
+
+// UnmarshalJSON implements json.Unmarshaler interface.
+func (argument *Argument) UnmarshalJSON(data []byte) error {
+ var arg ArgumentMarshaling
+ err := json.Unmarshal(data, &arg)
+ if err != nil {
+ return fmt.Errorf("argument json err: %v", err)
+ }
+
+ argument.Type, err = NewType(arg.Type, arg.InternalType, arg.Components)
+ if err != nil {
+ return err
+ }
+ argument.Name = arg.Name
+ argument.Indexed = arg.Indexed
+ argument.Offset = arg.Offset
+
+ return nil
+}
+
+// NonIndexed returns the arguments with indexed arguments filtered out.
+func (arguments Arguments) NonIndexed() Arguments {
+ var ret []Argument
+ for _, arg := range arguments {
+ if !arg.Indexed {
+ ret = append(ret, arg)
+ }
+ }
+ return ret
+}
+
+// isTuple returns true for non-atomic constructs, like (uint,uint) or uint[].
+func (arguments Arguments) isTuple() bool {
+ return len(arguments) > 1
+}
+
+// Unpack performs the operation hexdata -> Go format.
+func (arguments Arguments) Unpack(data []byte) ([]interface{}, error) {
+ if len(data) == 0 {
+ if len(arguments.NonIndexed()) != 0 {
+ return nil, fmt.Errorf("abi: attempting to unmarshall an empty string while arguments are expected")
+ }
+ return make([]interface{}, 0), nil
+ }
+ return arguments.UnpackValues(data)
+}
+
+// UnpackIntoMap performs the operation hexdata -> mapping of argument name to argument value.
+func (arguments Arguments) UnpackIntoMap(v map[string]interface{}, data []byte) error {
+ // Make sure map is not nil
+ if v == nil {
+ return fmt.Errorf("abi: cannot unpack into a nil map")
+ }
+ if len(data) == 0 {
+ if len(arguments.NonIndexed()) != 0 {
+ return fmt.Errorf("abi: attempting to unmarshall an empty string while arguments are expected")
+ }
+ return nil // Nothing to unmarshal, return
+ }
+ marshalledValues, err := arguments.UnpackValues(data)
+ if err != nil {
+ return err
+ }
+ for i, arg := range arguments.NonIndexed() {
+ v[arg.Name] = marshalledValues[i]
+ }
+ return nil
+}
+
+// Copy performs the operation go format -> provided struct.
+func (arguments Arguments) Copy(v interface{}, values []interface{}) error {
+ // make sure the passed value is arguments pointer
+ if reflect.Ptr != reflect.ValueOf(v).Kind() {
+ return fmt.Errorf("abi: Unpack(non-pointer %T)", v)
+ }
+ if len(values) == 0 {
+ if len(arguments.NonIndexed()) != 0 {
+ return fmt.Errorf("abi: attempting to copy no values while arguments are expected")
+ }
+ return nil // Nothing to copy, return
+ }
+ if arguments.isTuple() {
+ return arguments.copyTuple(v, values)
+ }
+ return arguments.copyAtomic(v, values[0])
+}
+
+// unpackAtomic unpacks ( hexdata -> go ) a single value
+func (arguments Arguments) copyAtomic(v interface{}, marshalledValues interface{}) error {
+ dst := reflect.ValueOf(v).Elem()
+ src := reflect.ValueOf(marshalledValues)
+
+ if dst.Kind() == reflect.Struct {
+ return set(dst.Field(0), src)
+ }
+ return set(dst, src)
+}
+
+// copyTuple copies a batch of values from marshalledValues to v.
+func (arguments Arguments) copyTuple(v interface{}, marshalledValues []interface{}) error {
+ value := reflect.ValueOf(v).Elem()
+ nonIndexedArgs := arguments.NonIndexed()
+
+ switch value.Kind() {
+ case reflect.Struct:
+ argNames := make([]string, len(nonIndexedArgs))
+ for i, arg := range nonIndexedArgs {
+ argNames[i] = arg.Name
+ }
+ var err error
+ abi2struct, err := mapArgNamesToStructFields(argNames, value)
+ if err != nil {
+ return err
+ }
+ for i, arg := range nonIndexedArgs {
+ field := value.FieldByName(abi2struct[arg.Name])
+ if !field.IsValid() {
+ return fmt.Errorf("abi: field %s can't be found in the given value", arg.Name)
+ }
+ if err := set(field, reflect.ValueOf(marshalledValues[i])); err != nil {
+ return err
+ }
+ }
+ case reflect.Slice, reflect.Array:
+ if value.Len() < len(marshalledValues) {
+ return fmt.Errorf("abi: insufficient number of arguments for unpack, want %d, got %d", len(arguments), value.Len())
+ }
+ for i := range nonIndexedArgs {
+ if err := set(value.Index(i), reflect.ValueOf(marshalledValues[i])); err != nil {
+ return err
+ }
+ }
+ default:
+ return fmt.Errorf("abi:[2] cannot unmarshal tuple in to %v", value.Type())
+ }
+ return nil
+}
+
+// UnpackValues can be used to unpack ABI-encoded hexdata according to the ABI-specification,
+// without supplying a struct to unpack into. Instead, this method returns a list containing the
+// values. An atomic argument will be a list with one element.
+func (arguments Arguments) UnpackValues(data []byte) ([]interface{}, error) {
+ nonIndexedArgs := arguments.NonIndexed()
+ retval := make([]interface{}, 0, len(nonIndexedArgs))
+ virtualArgs := 0
+ for index, arg := range nonIndexedArgs {
+ marshalledValue, err := toGoType((index+virtualArgs)*32, arg.Type, data)
+ if arg.Type.T == ArrayTy && !isDynamicType(arg.Type) {
+ // If we have a static array, like [3]uint256, these are coded as
+ // just like uint256,uint256,uint256.
+ // This means that we need to add two 'virtual' arguments when
+ // we count the index from now on.
+ //
+ // Array values nested multiple levels deep are also encoded inline:
+ // [2][3]uint256: uint256,uint256,uint256,uint256,uint256,uint256
+ //
+ // Calculate the full array size to get the correct offset for the next argument.
+ // Decrement it by 1, as the normal index increment is still applied.
+ virtualArgs += getTypeSize(arg.Type)/32 - 1
+ } else if arg.Type.T == TupleTy && !isDynamicType(arg.Type) {
+ // If we have a static tuple, like (uint256, bool, uint256), these are
+ // coded as just like uint256,bool,uint256
+ virtualArgs += getTypeSize(arg.Type)/32 - 1
+ }
+ if err != nil {
+ return nil, err
+ }
+ retval = append(retval, marshalledValue)
+ }
+ return retval, nil
+}
+
+// PackValues performs the operation Go format -> Hexdata.
+// It is the semantic opposite of UnpackValues.
+func (arguments Arguments) PackValues(args []interface{}) ([]byte, error) {
+ return arguments.Pack(args...)
+}
+
+// Pack performs the operation Go format -> Hexdata.
+func (arguments Arguments) Pack(args ...interface{}) ([]byte, error) {
+ // Make sure arguments match up and pack them
+ abiArgs := arguments
+ if len(args) != len(abiArgs) {
+ return nil, fmt.Errorf("argument count mismatch: got %d for %d", len(args), len(abiArgs))
+ }
+ // variable input is the output appended at the end of packed
+ // output. This is used for strings and bytes types input.
+ var variableInput []byte
+
+ // input offset is the bytes offset for packed output
+ inputOffset := 0
+ for _, abiArg := range abiArgs {
+ inputOffset += getTypeSize(abiArg.Type)
+ }
+ var ret []byte
+ for i, a := range args {
+ input := abiArgs[i]
+ // pack the input
+ packed, err := input.Type.pack(reflect.ValueOf(a))
+ if err != nil {
+ return nil, err
+ }
+ // check for dynamic types
+ if isDynamicType(input.Type) {
+ // set the offset
+ ret = append(ret, packNum(reflect.ValueOf(inputOffset))...)
+ // calculate next offset
+ inputOffset += len(packed)
+ // append to variable input
+ variableInput = append(variableInput, packed...)
+ } else {
+ // append the packed value to the input
+ ret = append(ret, packed...)
+ }
+ }
+ // append the variable input at the end of the packed input
+ ret = append(ret, variableInput...)
+
+ return ret, nil
+}
+
+// ToCamelCase converts an under-score string to a camel-case string
+func ToCamelCase(input string) string {
+ parts := strings.Split(input, "_")
+ for i, s := range parts {
+ if len(s) > 0 {
+ parts[i] = strings.ToUpper(s[:1]) + s[1:]
+ }
+ }
+ return strings.Join(parts, "")
+}
diff --git a/abigen/accounts/abi/bind/auth.go b/abigen/accounts/abi/bind/auth.go
new file mode 100644
index 00000000..494dc88a
--- /dev/null
+++ b/abigen/accounts/abi/bind/auth.go
@@ -0,0 +1,179 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package bind
+
+import (
+ "context"
+ "crypto/ecdsa"
+ "errors"
+ "io"
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/accounts"
+ "github.com/ethereum/go-ethereum/accounts/external"
+ "github.com/ethereum/go-ethereum/accounts/keystore"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/crypto"
+ "github.com/ethereum/go-ethereum/log"
+)
+
+// ErrNoChainID is returned whenever the user failed to specify a chain id.
+var ErrNoChainID = errors.New("no chain id specified")
+
+// ErrNotAuthorized is returned when an account is not properly unlocked.
+var ErrNotAuthorized = errors.New("not authorized to sign this account")
+
+// NewTransactor is a utility method to easily create a transaction signer from
+// an encrypted json key stream and the associated passphrase.
+//
+// Deprecated: Use NewTransactorWithChainID instead.
+func NewTransactor(keyin io.Reader, passphrase string) (*TransactOpts, error) {
+ log.Warn("WARNING: NewTransactor has been deprecated in favour of NewTransactorWithChainID")
+ json, err := io.ReadAll(keyin)
+ if err != nil {
+ return nil, err
+ }
+ key, err := keystore.DecryptKey(json, passphrase)
+ if err != nil {
+ return nil, err
+ }
+ return NewKeyedTransactor(key.PrivateKey), nil
+}
+
+// NewKeyStoreTransactor is a utility method to easily create a transaction signer from
+// an decrypted key from a keystore.
+//
+// Deprecated: Use NewKeyStoreTransactorWithChainID instead.
+func NewKeyStoreTransactor(keystore *keystore.KeyStore, account accounts.Account) (*TransactOpts, error) {
+ log.Warn("WARNING: NewKeyStoreTransactor has been deprecated in favour of NewTransactorWithChainID")
+ signer := types.HomesteadSigner{}
+ return &TransactOpts{
+ From: account.Address,
+ Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) {
+ if address != account.Address {
+ return nil, ErrNotAuthorized
+ }
+ signature, err := keystore.SignHash(account, signer.Hash(tx).Bytes())
+ if err != nil {
+ return nil, err
+ }
+ return tx.WithSignature(signer, signature)
+ },
+ Context: context.Background(),
+ }, nil
+}
+
+// NewKeyedTransactor is a utility method to easily create a transaction signer
+// from a single private key.
+//
+// Deprecated: Use NewKeyedTransactorWithChainID instead.
+func NewKeyedTransactor(key *ecdsa.PrivateKey) *TransactOpts {
+ log.Warn("WARNING: NewKeyedTransactor has been deprecated in favour of NewKeyedTransactorWithChainID")
+ keyAddr := crypto.PubkeyToAddress(key.PublicKey)
+ signer := types.HomesteadSigner{}
+ return &TransactOpts{
+ From: keyAddr,
+ Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) {
+ if address != keyAddr {
+ return nil, ErrNotAuthorized
+ }
+ signature, err := crypto.Sign(signer.Hash(tx).Bytes(), key)
+ if err != nil {
+ return nil, err
+ }
+ return tx.WithSignature(signer, signature)
+ },
+ Context: context.Background(),
+ }
+}
+
+// NewTransactorWithChainID is a utility method to easily create a transaction signer from
+// an encrypted json key stream and the associated passphrase.
+func NewTransactorWithChainID(keyin io.Reader, passphrase string, chainID *big.Int) (*TransactOpts, error) {
+ json, err := io.ReadAll(keyin)
+ if err != nil {
+ return nil, err
+ }
+ key, err := keystore.DecryptKey(json, passphrase)
+ if err != nil {
+ return nil, err
+ }
+ return NewKeyedTransactorWithChainID(key.PrivateKey, chainID)
+}
+
+// NewKeyStoreTransactorWithChainID is a utility method to easily create a transaction signer from
+// an decrypted key from a keystore.
+func NewKeyStoreTransactorWithChainID(keystore *keystore.KeyStore, account accounts.Account, chainID *big.Int) (*TransactOpts, error) {
+ if chainID == nil {
+ return nil, ErrNoChainID
+ }
+ signer := types.LatestSignerForChainID(chainID)
+ return &TransactOpts{
+ From: account.Address,
+ Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) {
+ if address != account.Address {
+ return nil, ErrNotAuthorized
+ }
+ signature, err := keystore.SignHash(account, signer.Hash(tx).Bytes())
+ if err != nil {
+ return nil, err
+ }
+ return tx.WithSignature(signer, signature)
+ },
+ Context: context.Background(),
+ }, nil
+}
+
+// NewKeyedTransactorWithChainID is a utility method to easily create a transaction signer
+// from a single private key.
+func NewKeyedTransactorWithChainID(key *ecdsa.PrivateKey, chainID *big.Int) (*TransactOpts, error) {
+ keyAddr := crypto.PubkeyToAddress(key.PublicKey)
+ if chainID == nil {
+ return nil, ErrNoChainID
+ }
+ signer := types.LatestSignerForChainID(chainID)
+ return &TransactOpts{
+ From: keyAddr,
+ Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) {
+ if address != keyAddr {
+ return nil, ErrNotAuthorized
+ }
+ signature, err := crypto.Sign(signer.Hash(tx).Bytes(), key)
+ if err != nil {
+ return nil, err
+ }
+ return tx.WithSignature(signer, signature)
+ },
+ Context: context.Background(),
+ }, nil
+}
+
+// NewClefTransactor is a utility method to easily create a transaction signer
+// with a clef backend.
+func NewClefTransactor(clef *external.ExternalSigner, account accounts.Account) *TransactOpts {
+ return &TransactOpts{
+ From: account.Address,
+ Signer: func(address common.Address, transaction *types.Transaction) (*types.Transaction, error) {
+ if address != account.Address {
+ return nil, ErrNotAuthorized
+ }
+ return clef.SignTx(account, transaction, nil) // Clef enforces its own chain id
+ },
+ Context: context.Background(),
+ }
+}
diff --git a/abigen/accounts/abi/bind/backend.go b/abigen/accounts/abi/bind/backend.go
new file mode 100644
index 00000000..c16990f3
--- /dev/null
+++ b/abigen/accounts/abi/bind/backend.go
@@ -0,0 +1,126 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package bind
+
+import (
+ "context"
+ "errors"
+ "math/big"
+
+ "github.com/ethereum/go-ethereum"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/core/types"
+)
+
+var (
+ // ErrNoCode is returned by call and transact operations for which the requested
+ // recipient contract to operate on does not exist in the state db or does not
+ // have any code associated with it (i.e. suicided).
+ ErrNoCode = errors.New("no contract code at given address")
+
+ // ErrNoPendingState is raised when attempting to perform a pending state action
+ // on a backend that doesn't implement PendingContractCaller.
+ ErrNoPendingState = errors.New("backend does not support pending state")
+
+ // ErrNoCodeAfterDeploy is returned by WaitDeployed if contract creation leaves
+ // an empty contract behind.
+ ErrNoCodeAfterDeploy = errors.New("no contract code after deployment")
+)
+
+// ContractCaller defines the methods needed to allow operating with a contract on a read
+// only basis.
+type ContractCaller interface {
+ // CodeAt returns the code of the given account. This is needed to differentiate
+ // between contract internal errors and the local chain being out of sync.
+ CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error)
+
+ // CallContract executes an Ethereum contract call with the specified data as the
+ // input.
+ CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error)
+}
+
+// PendingContractCaller defines methods to perform contract calls on the pending state.
+// Call will try to discover this interface when access to the pending state is requested.
+// If the backend does not support the pending state, Call returns ErrNoPendingState.
+type PendingContractCaller interface {
+ // PendingCodeAt returns the code of the given account in the pending state.
+ PendingCodeAt(ctx context.Context, contract common.Address) ([]byte, error)
+
+ // PendingCallContract executes an Ethereum contract call against the pending state.
+ PendingCallContract(ctx context.Context, call ethereum.CallMsg) ([]byte, error)
+}
+
+// ContractTransactor defines the methods needed to allow operating with a contract
+// on a write only basis. Besides the transacting method, the remainder are helpers
+// used when the user does not provide some needed values, but rather leaves it up
+// to the transactor to decide.
+type ContractTransactor interface {
+ // HeaderByNumber returns a block header from the current canonical chain. If
+ // number is nil, the latest known header is returned.
+ HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error)
+
+ // PendingCodeAt returns the code of the given account in the pending state.
+ PendingCodeAt(ctx context.Context, account common.Address) ([]byte, error)
+
+ // PendingNonceAt retrieves the current pending nonce associated with an account.
+ PendingNonceAt(ctx context.Context, account common.Address) (uint64, error)
+
+ // SuggestGasPrice retrieves the currently suggested gas price to allow a timely
+ // execution of a transaction.
+ SuggestGasPrice(ctx context.Context) (*big.Int, error)
+
+ // SuggestGasTipCap retrieves the currently suggested 1559 priority fee to allow
+ // a timely execution of a transaction.
+ SuggestGasTipCap(ctx context.Context) (*big.Int, error)
+
+ // EstimateGas tries to estimate the gas needed to execute a specific
+ // transaction based on the current pending state of the backend blockchain.
+ // There is no guarantee that this is the true gas limit requirement as other
+ // transactions may be added or removed by miners, but it should provide a basis
+ // for setting a reasonable default.
+ EstimateGas(ctx context.Context, call ethereum.CallMsg) (gas uint64, err error)
+
+ // SendTransaction injects the transaction into the pending pool for execution.
+ SendTransaction(ctx context.Context, tx *types.Transaction) error
+}
+
+// ContractFilterer defines the methods needed to access log events using one-off
+// queries or continuous event subscriptions.
+type ContractFilterer interface {
+ // FilterLogs executes a log filter operation, blocking during execution and
+ // returning all the results in one batch.
+ //
+ // TODO(karalabe): Deprecate when the subscription one can return past data too.
+ FilterLogs(ctx context.Context, query ethereum.FilterQuery) ([]types.Log, error)
+
+ // SubscribeFilterLogs creates a background log filtering operation, returning
+ // a subscription immediately, which can be used to stream the found events.
+ SubscribeFilterLogs(ctx context.Context, query ethereum.FilterQuery, ch chan<- types.Log) (ethereum.Subscription, error)
+}
+
+// DeployBackend wraps the operations needed by WaitMined and WaitDeployed.
+type DeployBackend interface {
+ TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error)
+ CodeAt(ctx context.Context, account common.Address, blockNumber *big.Int) ([]byte, error)
+}
+
+// ContractBackend defines the methods needed to work with contracts on a read-write basis.
+type ContractBackend interface {
+ ContractCaller
+ ContractTransactor
+ ContractFilterer
+}
diff --git a/abigen/accounts/abi/bind/backends/simulated.go b/abigen/accounts/abi/bind/backends/simulated.go
new file mode 100644
index 00000000..f5780c4a
--- /dev/null
+++ b/abigen/accounts/abi/bind/backends/simulated.go
@@ -0,0 +1,899 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package backends
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "math/big"
+ "sync"
+ "time"
+
+ "github.com/ethereum/go-ethereum"
+ "github.com/ethereum/go-ethereum/accounts/abi"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/ethereum/go-ethereum/common/math"
+ "github.com/ethereum/go-ethereum/consensus/ethash"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/core/bloombits"
+ "github.com/ethereum/go-ethereum/core/rawdb"
+ "github.com/ethereum/go-ethereum/core/state"
+ "github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/core/vm"
+ "github.com/ethereum/go-ethereum/eth/filters"
+ "github.com/ethereum/go-ethereum/ethdb"
+ "github.com/ethereum/go-ethereum/event"
+ "github.com/ethereum/go-ethereum/log"
+ "github.com/ethereum/go-ethereum/params"
+ "github.com/ethereum/go-ethereum/rpc"
+)
+
+// This nil assignment ensures at compile time that SimulatedBackend implements bind.ContractBackend.
+var _ bind.ContractBackend = (*SimulatedBackend)(nil)
+
+var (
+ errBlockNumberUnsupported = errors.New("simulatedBackend cannot access blocks other than the latest block")
+ errBlockDoesNotExist = errors.New("block does not exist in blockchain")
+ errTransactionDoesNotExist = errors.New("transaction does not exist")
+)
+
+// SimulatedBackend implements bind.ContractBackend, simulating a blockchain in
+// the background. Its main purpose is to allow for easy testing of contract bindings.
+// Simulated backend implements the following interfaces:
+// ChainReader, ChainStateReader, ContractBackend, ContractCaller, ContractFilterer, ContractTransactor,
+// DeployBackend, GasEstimator, GasPricer, LogFilterer, PendingContractCaller, TransactionReader, and TransactionSender
+type SimulatedBackend struct {
+ database ethdb.Database // In memory database to store our testing data
+ blockchain *core.BlockChain // Ethereum blockchain to handle the consensus
+
+ mu sync.Mutex
+ pendingBlock *types.Block // Currently pending block that will be imported on request
+ pendingState *state.StateDB // Currently pending state that will be the active on request
+ pendingReceipts types.Receipts // Currently receipts for the pending block
+
+ events *filters.EventSystem // Event system for filtering log events live
+
+ config *params.ChainConfig
+}
+
+// NewSimulatedBackendWithDatabase creates a new binding backend based on the given database
+// and uses a simulated blockchain for testing purposes.
+// A simulated backend always uses chainID 1337.
+func NewSimulatedBackendWithDatabase(database ethdb.Database, alloc core.GenesisAlloc, gasLimit uint64) *SimulatedBackend {
+ genesis := core.Genesis{Config: params.AllEthashProtocolChanges, GasLimit: gasLimit, Alloc: alloc}
+ genesis.MustCommit(database)
+ blockchain, _ := core.NewBlockChain(database, nil, genesis.Config, ethash.NewFaker(), vm.Config{}, nil, nil)
+
+ backend := &SimulatedBackend{
+ database: database,
+ blockchain: blockchain,
+ config: genesis.Config,
+ }
+ backend.events = filters.NewEventSystem(&filterBackend{database, blockchain, backend}, false)
+ backend.rollback(blockchain.CurrentBlock())
+ return backend
+}
+
+// NewSimulatedBackend creates a new binding backend using a simulated blockchain
+// for testing purposes.
+// A simulated backend always uses chainID 1337.
+func NewSimulatedBackend(alloc core.GenesisAlloc, gasLimit uint64) *SimulatedBackend {
+ return NewSimulatedBackendWithDatabase(rawdb.NewMemoryDatabase(), alloc, gasLimit)
+}
+
+// Close terminates the underlying blockchain's update loop.
+func (b *SimulatedBackend) Close() error {
+ b.blockchain.Stop()
+ return nil
+}
+
+// Commit imports all the pending transactions as a single block and starts a
+// fresh new state.
+func (b *SimulatedBackend) Commit() {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ if _, err := b.blockchain.InsertChain([]*types.Block{b.pendingBlock}); err != nil {
+ panic(err) // This cannot happen unless the simulator is wrong, fail in that case
+ }
+ // Using the last inserted block here makes it possible to build on a side
+ // chain after a fork.
+ b.rollback(b.pendingBlock)
+}
+
+// Rollback aborts all pending transactions, reverting to the last committed state.
+func (b *SimulatedBackend) Rollback() {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ b.rollback(b.blockchain.CurrentBlock())
+}
+
+func (b *SimulatedBackend) rollback(parent *types.Block) {
+ blocks, _ := core.GenerateChain(b.config, parent, ethash.NewFaker(), b.database, 1, func(int, *core.BlockGen) {})
+
+ b.pendingBlock = blocks[0]
+ b.pendingState, _ = state.New(b.pendingBlock.Root(), b.blockchain.StateCache(), nil)
+}
+
+// Fork creates a side-chain that can be used to simulate reorgs.
+//
+// This function should be called with the ancestor block where the new side
+// chain should be started. Transactions (old and new) can then be applied on
+// top and Commit-ed.
+//
+// Note, the side-chain will only become canonical (and trigger the events) when
+// it becomes longer. Until then CallContract will still operate on the current
+// canonical chain.
+//
+// There is a % chance that the side chain becomes canonical at the same length
+// to simulate live network behavior.
+func (b *SimulatedBackend) Fork(ctx context.Context, parent common.Hash) error {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ if len(b.pendingBlock.Transactions()) != 0 {
+ return errors.New("pending block dirty")
+ }
+ block, err := b.blockByHash(ctx, parent)
+ if err != nil {
+ return err
+ }
+ b.rollback(block)
+ return nil
+}
+
+// stateByBlockNumber retrieves a state by a given blocknumber.
+func (b *SimulatedBackend) stateByBlockNumber(ctx context.Context, blockNumber *big.Int) (*state.StateDB, error) {
+ if blockNumber == nil || blockNumber.Cmp(b.blockchain.CurrentBlock().Number()) == 0 {
+ return b.blockchain.State()
+ }
+ block, err := b.blockByNumber(ctx, blockNumber)
+ if err != nil {
+ return nil, err
+ }
+ return b.blockchain.StateAt(block.Root())
+}
+
+// CodeAt returns the code associated with a certain account in the blockchain.
+func (b *SimulatedBackend) CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ stateDB, err := b.stateByBlockNumber(ctx, blockNumber)
+ if err != nil {
+ return nil, err
+ }
+
+ return stateDB.GetCode(contract), nil
+}
+
+// BalanceAt returns the wei balance of a certain account in the blockchain.
+func (b *SimulatedBackend) BalanceAt(ctx context.Context, contract common.Address, blockNumber *big.Int) (*big.Int, error) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ stateDB, err := b.stateByBlockNumber(ctx, blockNumber)
+ if err != nil {
+ return nil, err
+ }
+
+ return stateDB.GetBalance(contract), nil
+}
+
+// NonceAt returns the nonce of a certain account in the blockchain.
+func (b *SimulatedBackend) NonceAt(ctx context.Context, contract common.Address, blockNumber *big.Int) (uint64, error) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ stateDB, err := b.stateByBlockNumber(ctx, blockNumber)
+ if err != nil {
+ return 0, err
+ }
+
+ return stateDB.GetNonce(contract), nil
+}
+
+// StorageAt returns the value of key in the storage of an account in the blockchain.
+func (b *SimulatedBackend) StorageAt(ctx context.Context, contract common.Address, key common.Hash, blockNumber *big.Int) ([]byte, error) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ stateDB, err := b.stateByBlockNumber(ctx, blockNumber)
+ if err != nil {
+ return nil, err
+ }
+
+ val := stateDB.GetState(contract, key)
+ return val[:], nil
+}
+
+// TransactionReceipt returns the receipt of a transaction.
+func (b *SimulatedBackend) TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ receipt, _, _, _ := rawdb.ReadReceipt(b.database, txHash, b.config)
+ if receipt == nil {
+ return nil, ethereum.NotFound
+ }
+ return receipt, nil
+}
+
+// TransactionByHash checks the pool of pending transactions in addition to the
+// blockchain. The isPending return value indicates whether the transaction has been
+// mined yet. Note that the transaction may not be part of the canonical chain even if
+// it's not pending.
+func (b *SimulatedBackend) TransactionByHash(ctx context.Context, txHash common.Hash) (*types.Transaction, bool, error) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ tx := b.pendingBlock.Transaction(txHash)
+ if tx != nil {
+ return tx, true, nil
+ }
+ tx, _, _, _ = rawdb.ReadTransaction(b.database, txHash)
+ if tx != nil {
+ return tx, false, nil
+ }
+ return nil, false, ethereum.NotFound
+}
+
+// BlockByHash retrieves a block based on the block hash.
+func (b *SimulatedBackend) BlockByHash(ctx context.Context, hash common.Hash) (*types.Block, error) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ return b.blockByHash(ctx, hash)
+}
+
+// blockByHash retrieves a block based on the block hash without Locking.
+func (b *SimulatedBackend) blockByHash(ctx context.Context, hash common.Hash) (*types.Block, error) {
+ if hash == b.pendingBlock.Hash() {
+ return b.pendingBlock, nil
+ }
+
+ block := b.blockchain.GetBlockByHash(hash)
+ if block != nil {
+ return block, nil
+ }
+
+ return nil, errBlockDoesNotExist
+}
+
+// BlockByNumber retrieves a block from the database by number, caching it
+// (associated with its hash) if found.
+func (b *SimulatedBackend) BlockByNumber(ctx context.Context, number *big.Int) (*types.Block, error) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ return b.blockByNumber(ctx, number)
+}
+
+// blockByNumber retrieves a block from the database by number, caching it
+// (associated with its hash) if found without Lock.
+func (b *SimulatedBackend) blockByNumber(ctx context.Context, number *big.Int) (*types.Block, error) {
+ if number == nil || number.Cmp(b.pendingBlock.Number()) == 0 {
+ return b.blockchain.CurrentBlock(), nil
+ }
+
+ block := b.blockchain.GetBlockByNumber(uint64(number.Int64()))
+ if block == nil {
+ return nil, errBlockDoesNotExist
+ }
+
+ return block, nil
+}
+
+// HeaderByHash returns a block header from the current canonical chain.
+func (b *SimulatedBackend) HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ if hash == b.pendingBlock.Hash() {
+ return b.pendingBlock.Header(), nil
+ }
+
+ header := b.blockchain.GetHeaderByHash(hash)
+ if header == nil {
+ return nil, errBlockDoesNotExist
+ }
+
+ return header, nil
+}
+
+// HeaderByNumber returns a block header from the current canonical chain. If number is
+// nil, the latest known header is returned.
+func (b *SimulatedBackend) HeaderByNumber(ctx context.Context, block *big.Int) (*types.Header, error) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ if block == nil || block.Cmp(b.pendingBlock.Number()) == 0 {
+ return b.blockchain.CurrentHeader(), nil
+ }
+
+ return b.blockchain.GetHeaderByNumber(uint64(block.Int64())), nil
+}
+
+// TransactionCount returns the number of transactions in a given block.
+func (b *SimulatedBackend) TransactionCount(ctx context.Context, blockHash common.Hash) (uint, error) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ if blockHash == b.pendingBlock.Hash() {
+ return uint(b.pendingBlock.Transactions().Len()), nil
+ }
+
+ block := b.blockchain.GetBlockByHash(blockHash)
+ if block == nil {
+ return uint(0), errBlockDoesNotExist
+ }
+
+ return uint(block.Transactions().Len()), nil
+}
+
+// TransactionInBlock returns the transaction for a specific block at a specific index.
+func (b *SimulatedBackend) TransactionInBlock(ctx context.Context, blockHash common.Hash, index uint) (*types.Transaction, error) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ if blockHash == b.pendingBlock.Hash() {
+ transactions := b.pendingBlock.Transactions()
+ if uint(len(transactions)) < index+1 {
+ return nil, errTransactionDoesNotExist
+ }
+
+ return transactions[index], nil
+ }
+
+ block := b.blockchain.GetBlockByHash(blockHash)
+ if block == nil {
+ return nil, errBlockDoesNotExist
+ }
+
+ transactions := block.Transactions()
+ if uint(len(transactions)) < index+1 {
+ return nil, errTransactionDoesNotExist
+ }
+
+ return transactions[index], nil
+}
+
+// PendingCodeAt returns the code associated with an account in the pending state.
+func (b *SimulatedBackend) PendingCodeAt(ctx context.Context, contract common.Address) ([]byte, error) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ return b.pendingState.GetCode(contract), nil
+}
+
+func newRevertError(result *core.ExecutionResult) *revertError {
+ reason, errUnpack := abi.UnpackRevert(result.Revert())
+ err := errors.New("execution reverted")
+ if errUnpack == nil {
+ err = fmt.Errorf("execution reverted: %v", reason)
+ }
+ return &revertError{
+ error: err,
+ reason: hexutil.Encode(result.Revert()),
+ }
+}
+
+// revertError is an API error that encompasses an EVM revert with JSON error
+// code and a binary data blob.
+type revertError struct {
+ error
+ reason string // revert reason hex encoded
+}
+
+// ErrorCode returns the JSON error code for a revert.
+// See: https://github.com/ethereum/wiki/wiki/JSON-RPC-Error-Codes-Improvement-Proposal
+func (e *revertError) ErrorCode() int {
+ return 3
+}
+
+// ErrorData returns the hex encoded revert reason.
+func (e *revertError) ErrorData() interface{} {
+ return e.reason
+}
+
+// CallContract executes a contract call.
+func (b *SimulatedBackend) CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ if blockNumber != nil && blockNumber.Cmp(b.blockchain.CurrentBlock().Number()) != 0 {
+ return nil, errBlockNumberUnsupported
+ }
+ stateDB, err := b.blockchain.State()
+ if err != nil {
+ return nil, err
+ }
+ res, err := b.callContract(ctx, call, b.blockchain.CurrentBlock(), stateDB)
+ if err != nil {
+ return nil, err
+ }
+ // If the result contains a revert reason, try to unpack and return it.
+ if len(res.Revert()) > 0 {
+ return nil, newRevertError(res)
+ }
+ return res.Return(), res.Err
+}
+
+// PendingCallContract executes a contract call on the pending state.
+func (b *SimulatedBackend) PendingCallContract(ctx context.Context, call ethereum.CallMsg) ([]byte, error) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+ defer b.pendingState.RevertToSnapshot(b.pendingState.Snapshot())
+
+ res, err := b.callContract(ctx, call, b.pendingBlock, b.pendingState)
+ if err != nil {
+ return nil, err
+ }
+ // If the result contains a revert reason, try to unpack and return it.
+ if len(res.Revert()) > 0 {
+ return nil, newRevertError(res)
+ }
+ return res.Return(), res.Err
+}
+
+// PendingNonceAt implements PendingStateReader.PendingNonceAt, retrieving
+// the nonce currently pending for the account.
+func (b *SimulatedBackend) PendingNonceAt(ctx context.Context, account common.Address) (uint64, error) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ return b.pendingState.GetOrNewStateObject(account).Nonce(), nil
+}
+
+// SuggestGasPrice implements ContractTransactor.SuggestGasPrice. Since the simulated
+// chain doesn't have miners, we just return a gas price of 1 for any call.
+func (b *SimulatedBackend) SuggestGasPrice(ctx context.Context) (*big.Int, error) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ if b.pendingBlock.Header().BaseFee != nil {
+ return b.pendingBlock.Header().BaseFee, nil
+ }
+ return big.NewInt(1), nil
+}
+
+// SuggestGasTipCap implements ContractTransactor.SuggestGasTipCap. Since the simulated
+// chain doesn't have miners, we just return a gas tip of 1 for any call.
+func (b *SimulatedBackend) SuggestGasTipCap(ctx context.Context) (*big.Int, error) {
+ return big.NewInt(1), nil
+}
+
+// EstimateGas executes the requested code against the currently pending block/state and
+// returns the used amount of gas.
+func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMsg) (uint64, error) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ // Determine the lowest and highest possible gas limits to binary search in between
+ var (
+ lo uint64 = params.TxGas - 1
+ hi uint64
+ cap uint64
+ )
+ if call.Gas >= params.TxGas {
+ hi = call.Gas
+ } else {
+ hi = b.pendingBlock.GasLimit()
+ }
+ // Normalize the max fee per gas the call is willing to spend.
+ var feeCap *big.Int
+ if call.GasPrice != nil && (call.GasFeeCap != nil || call.GasTipCap != nil) {
+ return 0, errors.New("both gasPrice and (maxFeePerGas or maxPriorityFeePerGas) specified")
+ } else if call.GasPrice != nil {
+ feeCap = call.GasPrice
+ } else if call.GasFeeCap != nil {
+ feeCap = call.GasFeeCap
+ } else {
+ feeCap = common.Big0
+ }
+ // Recap the highest gas allowance with account's balance.
+ if feeCap.BitLen() != 0 {
+ balance := b.pendingState.GetBalance(call.From) // from can't be nil
+ available := new(big.Int).Set(balance)
+ if call.Value != nil {
+ if call.Value.Cmp(available) >= 0 {
+ return 0, errors.New("insufficient funds for transfer")
+ }
+ available.Sub(available, call.Value)
+ }
+ allowance := new(big.Int).Div(available, feeCap)
+ if allowance.IsUint64() && hi > allowance.Uint64() {
+ transfer := call.Value
+ if transfer == nil {
+ transfer = new(big.Int)
+ }
+ log.Warn("Gas estimation capped by limited funds", "original", hi, "balance", balance,
+ "sent", transfer, "feecap", feeCap, "fundable", allowance)
+ hi = allowance.Uint64()
+ }
+ }
+ cap = hi
+
+ // Create a helper to check if a gas allowance results in an executable transaction
+ executable := func(gas uint64) (bool, *core.ExecutionResult, error) {
+ call.Gas = gas
+
+ snapshot := b.pendingState.Snapshot()
+ res, err := b.callContract(ctx, call, b.pendingBlock, b.pendingState)
+ b.pendingState.RevertToSnapshot(snapshot)
+
+ if err != nil {
+ if errors.Is(err, core.ErrIntrinsicGas) {
+ return true, nil, nil // Special case, raise gas limit
+ }
+ return true, nil, err // Bail out
+ }
+ return res.Failed(), res, nil
+ }
+ // Execute the binary search and hone in on an executable gas limit
+ for lo+1 < hi {
+ mid := (hi + lo) / 2
+ failed, _, err := executable(mid)
+
+ // If the error is not nil(consensus error), it means the provided message
+ // call or transaction will never be accepted no matter how much gas it is
+ // assigned. Return the error directly, don't struggle any more
+ if err != nil {
+ return 0, err
+ }
+ if failed {
+ lo = mid
+ } else {
+ hi = mid
+ }
+ }
+ // Reject the transaction as invalid if it still fails at the highest allowance
+ if hi == cap {
+ failed, result, err := executable(hi)
+ if err != nil {
+ return 0, err
+ }
+ if failed {
+ if result != nil && result.Err != vm.ErrOutOfGas {
+ if len(result.Revert()) > 0 {
+ return 0, newRevertError(result)
+ }
+ return 0, result.Err
+ }
+ // Otherwise, the specified gas cap is too low
+ return 0, fmt.Errorf("gas required exceeds allowance (%d)", cap)
+ }
+ }
+ return hi, nil
+}
+
+// callContract implements common code between normal and pending contract calls.
+// state is modified during execution, make sure to copy it if necessary.
+func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallMsg, block *types.Block, stateDB *state.StateDB) (*core.ExecutionResult, error) {
+ // Gas prices post 1559 need to be initialized
+ if call.GasPrice != nil && (call.GasFeeCap != nil || call.GasTipCap != nil) {
+ return nil, errors.New("both gasPrice and (maxFeePerGas or maxPriorityFeePerGas) specified")
+ }
+ head := b.blockchain.CurrentHeader()
+ if !b.blockchain.Config().IsLondon(head.Number) {
+ // If there's no basefee, then it must be a non-1559 execution
+ if call.GasPrice == nil {
+ call.GasPrice = new(big.Int)
+ }
+ call.GasFeeCap, call.GasTipCap = call.GasPrice, call.GasPrice
+ } else {
+ // A basefee is provided, necessitating 1559-type execution
+ if call.GasPrice != nil {
+ // User specified the legacy gas field, convert to 1559 gas typing
+ call.GasFeeCap, call.GasTipCap = call.GasPrice, call.GasPrice
+ } else {
+ // User specified 1559 gas feilds (or none), use those
+ if call.GasFeeCap == nil {
+ call.GasFeeCap = new(big.Int)
+ }
+ if call.GasTipCap == nil {
+ call.GasTipCap = new(big.Int)
+ }
+ // Backfill the legacy gasPrice for EVM execution, unless we're all zeroes
+ call.GasPrice = new(big.Int)
+ if call.GasFeeCap.BitLen() > 0 || call.GasTipCap.BitLen() > 0 {
+ call.GasPrice = math.BigMin(new(big.Int).Add(call.GasTipCap, head.BaseFee), call.GasFeeCap)
+ }
+ }
+ }
+ // Ensure message is initialized properly.
+ if call.Gas == 0 {
+ call.Gas = 50000000
+ }
+ if call.Value == nil {
+ call.Value = new(big.Int)
+ }
+ // Set infinite balance to the fake caller account.
+ from := stateDB.GetOrNewStateObject(call.From)
+ from.SetBalance(math.MaxBig256)
+ // Execute the call.
+ msg := callMsg{call}
+
+ txContext := core.NewEVMTxContext(msg)
+ evmContext := core.NewEVMBlockContext(block.Header(), b.blockchain, nil)
+ // Create a new environment which holds all relevant information
+ // about the transaction and calling mechanisms.
+ vmEnv := vm.NewEVM(evmContext, txContext, stateDB, b.config, vm.Config{NoBaseFee: true})
+ gasPool := new(core.GasPool).AddGas(math.MaxUint64)
+
+ return core.NewStateTransition(vmEnv, msg, gasPool).TransitionDb()
+}
+
+// SendTransaction updates the pending block to include the given transaction.
+func (b *SimulatedBackend) SendTransaction(ctx context.Context, tx *types.Transaction) error {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ // Get the last block
+ block, err := b.blockByHash(ctx, b.pendingBlock.ParentHash())
+ if err != nil {
+ return fmt.Errorf("could not fetch parent")
+ }
+ // Check transaction validity
+ signer := types.MakeSigner(b.blockchain.Config(), block.Number())
+ sender, err := types.Sender(signer, tx)
+ if err != nil {
+ return fmt.Errorf("invalid transaction: %v", err)
+ }
+ nonce := b.pendingState.GetNonce(sender)
+ if tx.Nonce() != nonce {
+ return fmt.Errorf("invalid transaction nonce: got %d, want %d", tx.Nonce(), nonce)
+ }
+ // Include tx in chain
+ blocks, receipts := core.GenerateChain(b.config, block, ethash.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) {
+ for _, tx := range b.pendingBlock.Transactions() {
+ block.AddTxWithChain(b.blockchain, tx)
+ }
+ block.AddTxWithChain(b.blockchain, tx)
+ })
+ stateDB, _ := b.blockchain.State()
+
+ b.pendingBlock = blocks[0]
+ b.pendingState, _ = state.New(b.pendingBlock.Root(), stateDB.Database(), nil)
+ b.pendingReceipts = receipts[0]
+ return nil
+}
+
+// FilterLogs executes a log filter operation, blocking during execution and
+// returning all the results in one batch.
+//
+// TODO(karalabe): Deprecate when the subscription one can return past data too.
+func (b *SimulatedBackend) FilterLogs(ctx context.Context, query ethereum.FilterQuery) ([]types.Log, error) {
+ var filter *filters.Filter
+ if query.BlockHash != nil {
+ // Block filter requested, construct a single-shot filter
+ filter = filters.NewBlockFilter(&filterBackend{b.database, b.blockchain, b}, *query.BlockHash, query.Addresses, query.Topics)
+ } else {
+ // Initialize unset filter boundaries to run from genesis to chain head
+ from := int64(0)
+ if query.FromBlock != nil {
+ from = query.FromBlock.Int64()
+ }
+ to := int64(-1)
+ if query.ToBlock != nil {
+ to = query.ToBlock.Int64()
+ }
+ // Construct the range filter
+ filter = filters.NewRangeFilter(&filterBackend{b.database, b.blockchain, b}, from, to, query.Addresses, query.Topics)
+ }
+ // Run the filter and return all the logs
+ logs, err := filter.Logs(ctx)
+ if err != nil {
+ return nil, err
+ }
+ res := make([]types.Log, len(logs))
+ for i, nLog := range logs {
+ res[i] = *nLog
+ }
+ return res, nil
+}
+
+// SubscribeFilterLogs creates a background log filtering operation, returning a
+// subscription immediately, which can be used to stream the found events.
+func (b *SimulatedBackend) SubscribeFilterLogs(ctx context.Context, query ethereum.FilterQuery, ch chan<- types.Log) (ethereum.Subscription, error) {
+ // Subscribe to contract events
+ sink := make(chan []*types.Log)
+
+ sub, err := b.events.SubscribeLogs(query, sink)
+ if err != nil {
+ return nil, err
+ }
+ // Since we're getting logs in batches, we need to flatten them into a plain stream
+ return event.NewSubscription(func(quit <-chan struct{}) error {
+ defer sub.Unsubscribe()
+ for {
+ select {
+ case logs := <-sink:
+ for _, nlog := range logs {
+ select {
+ case ch <- *nlog:
+ case err := <-sub.Err():
+ return err
+ case <-quit:
+ return nil
+ }
+ }
+ case err := <-sub.Err():
+ return err
+ case <-quit:
+ return nil
+ }
+ }
+ }), nil
+}
+
+// SubscribeNewHead returns an event subscription for a new header.
+func (b *SimulatedBackend) SubscribeNewHead(ctx context.Context, ch chan<- *types.Header) (ethereum.Subscription, error) {
+ // subscribe to a new head
+ sink := make(chan *types.Header)
+ sub := b.events.SubscribeNewHeads(sink)
+
+ return event.NewSubscription(func(quit <-chan struct{}) error {
+ defer sub.Unsubscribe()
+ for {
+ select {
+ case head := <-sink:
+ select {
+ case ch <- head:
+ case err := <-sub.Err():
+ return err
+ case <-quit:
+ return nil
+ }
+ case err := <-sub.Err():
+ return err
+ case <-quit:
+ return nil
+ }
+ }
+ }), nil
+}
+
+// AdjustTime adds a time shift to the simulated clock.
+// It can only be called on empty blocks.
+func (b *SimulatedBackend) AdjustTime(adjustment time.Duration) error {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ if len(b.pendingBlock.Transactions()) != 0 {
+ return errors.New("Could not adjust time on non-empty block")
+ }
+
+ blocks, _ := core.GenerateChain(b.config, b.blockchain.CurrentBlock(), ethash.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) {
+ block.OffsetTime(int64(adjustment.Seconds()))
+ })
+ stateDB, _ := b.blockchain.State()
+
+ b.pendingBlock = blocks[0]
+ b.pendingState, _ = state.New(b.pendingBlock.Root(), stateDB.Database(), nil)
+
+ return nil
+}
+
+// Blockchain returns the underlying blockchain.
+func (b *SimulatedBackend) Blockchain() *core.BlockChain {
+ return b.blockchain
+}
+
+// callMsg implements core.Message to allow passing it as a transaction simulator.
+type callMsg struct {
+ ethereum.CallMsg
+}
+
+func (m callMsg) From() common.Address { return m.CallMsg.From }
+func (m callMsg) Nonce() uint64 { return 0 }
+func (m callMsg) IsFake() bool { return true }
+func (m callMsg) To() *common.Address { return m.CallMsg.To }
+func (m callMsg) GasPrice() *big.Int { return m.CallMsg.GasPrice }
+func (m callMsg) GasFeeCap() *big.Int { return m.CallMsg.GasFeeCap }
+func (m callMsg) GasTipCap() *big.Int { return m.CallMsg.GasTipCap }
+func (m callMsg) Gas() uint64 { return m.CallMsg.Gas }
+func (m callMsg) Value() *big.Int { return m.CallMsg.Value }
+func (m callMsg) Data() []byte { return m.CallMsg.Data }
+func (m callMsg) AccessList() types.AccessList { return m.CallMsg.AccessList }
+
+// filterBackend implements filters.Backend to support filtering for logs without
+// taking bloom-bits acceleration structures into account.
+type filterBackend struct {
+ db ethdb.Database
+ bc *core.BlockChain
+ backend *SimulatedBackend
+}
+
+func (fb *filterBackend) ChainDb() ethdb.Database { return fb.db }
+func (fb *filterBackend) EventMux() *event.TypeMux { panic("not supported") }
+
+func (fb *filterBackend) HeaderByNumber(ctx context.Context, block rpc.BlockNumber) (*types.Header, error) {
+ if block == rpc.LatestBlockNumber {
+ return fb.bc.CurrentHeader(), nil
+ }
+ return fb.bc.GetHeaderByNumber(uint64(block.Int64())), nil
+}
+
+func (fb *filterBackend) HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error) {
+ return fb.bc.GetHeaderByHash(hash), nil
+}
+
+func (fb *filterBackend) PendingBlockAndReceipts() (*types.Block, types.Receipts) {
+ return fb.backend.pendingBlock, fb.backend.pendingReceipts
+}
+
+func (fb *filterBackend) GetReceipts(ctx context.Context, hash common.Hash) (types.Receipts, error) {
+ number := rawdb.ReadHeaderNumber(fb.db, hash)
+ if number == nil {
+ return nil, nil
+ }
+ return rawdb.ReadReceipts(fb.db, hash, *number, fb.bc.Config()), nil
+}
+
+func (fb *filterBackend) GetLogs(ctx context.Context, hash common.Hash) ([][]*types.Log, error) {
+ number := rawdb.ReadHeaderNumber(fb.db, hash)
+ if number == nil {
+ return nil, nil
+ }
+ receipts := rawdb.ReadReceipts(fb.db, hash, *number, fb.bc.Config())
+ if receipts == nil {
+ return nil, nil
+ }
+ logs := make([][]*types.Log, len(receipts))
+ for i, receipt := range receipts {
+ logs[i] = receipt.Logs
+ }
+ return logs, nil
+}
+
+func (fb *filterBackend) SubscribeNewTxsEvent(ch chan<- core.NewTxsEvent) event.Subscription {
+ return nullSubscription()
+}
+
+func (fb *filterBackend) SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription {
+ return fb.bc.SubscribeChainEvent(ch)
+}
+
+func (fb *filterBackend) SubscribeRemovedLogsEvent(ch chan<- core.RemovedLogsEvent) event.Subscription {
+ return fb.bc.SubscribeRemovedLogsEvent(ch)
+}
+
+func (fb *filterBackend) SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscription {
+ return fb.bc.SubscribeLogsEvent(ch)
+}
+
+func (fb *filterBackend) SubscribePendingLogsEvent(ch chan<- []*types.Log) event.Subscription {
+ return nullSubscription()
+}
+
+func (fb *filterBackend) BloomStatus() (uint64, uint64) { return 4096, 0 }
+
+func (fb *filterBackend) ServiceFilter(ctx context.Context, ms *bloombits.MatcherSession) {
+ panic("not supported")
+}
+
+func nullSubscription() event.Subscription {
+ return event.NewSubscription(func(quit <-chan struct{}) error {
+ <-quit
+ return nil
+ })
+}
diff --git a/abigen/accounts/abi/bind/backends/simulated_test.go b/abigen/accounts/abi/bind/backends/simulated_test.go
new file mode 100644
index 00000000..2287055e
--- /dev/null
+++ b/abigen/accounts/abi/bind/backends/simulated_test.go
@@ -0,0 +1,1337 @@
+// Copyright 2019 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package backends
+
+import (
+ "bytes"
+ "context"
+ "errors"
+ "math/big"
+ "math/rand"
+ "reflect"
+ "strings"
+ "testing"
+ "time"
+
+ "github.com/ethereum/go-ethereum"
+ "github.com/ethereum/go-ethereum/accounts/abi"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/crypto"
+ "github.com/ethereum/go-ethereum/params"
+)
+
+func TestSimulatedBackend(t *testing.T) {
+ var gasLimit uint64 = 8000029
+ key, _ := crypto.GenerateKey() // nolint: gosec
+ auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
+ genAlloc := make(core.GenesisAlloc)
+ genAlloc[auth.From] = core.GenesisAccount{Balance: big.NewInt(9223372036854775807)}
+
+ sim := NewSimulatedBackend(genAlloc, gasLimit)
+ defer sim.Close()
+
+ // should return an error if the tx is not found
+ txHash := common.HexToHash("2")
+ _, isPending, err := sim.TransactionByHash(context.Background(), txHash)
+
+ if isPending {
+ t.Fatal("transaction should not be pending")
+ }
+ if err != ethereum.NotFound {
+ t.Fatalf("err should be `ethereum.NotFound` but received %v", err)
+ }
+
+ // generate a transaction and confirm you can retrieve it
+ head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough
+ gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1))
+
+ code := `6060604052600a8060106000396000f360606040526008565b00`
+ var gas uint64 = 3000000
+ tx := types.NewContractCreation(0, big.NewInt(0), gas, gasPrice, common.FromHex(code))
+ tx, _ = types.SignTx(tx, types.HomesteadSigner{}, key)
+
+ err = sim.SendTransaction(context.Background(), tx)
+ if err != nil {
+ t.Fatal("error sending transaction")
+ }
+
+ txHash = tx.Hash()
+ _, isPending, err = sim.TransactionByHash(context.Background(), txHash)
+ if err != nil {
+ t.Fatalf("error getting transaction with hash: %v", txHash.String())
+ }
+ if !isPending {
+ t.Fatal("transaction should have pending status")
+ }
+
+ sim.Commit()
+ _, isPending, err = sim.TransactionByHash(context.Background(), txHash)
+ if err != nil {
+ t.Fatalf("error getting transaction with hash: %v", txHash.String())
+ }
+ if isPending {
+ t.Fatal("transaction should not have pending status")
+ }
+}
+
+var testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
+
+// the following is based on this contract:
+// contract T {
+// event received(address sender, uint amount, bytes memo);
+// event receivedAddr(address sender);
+//
+// function receive(bytes calldata memo) external payable returns (string memory res) {
+// emit received(msg.sender, msg.value, memo);
+// emit receivedAddr(msg.sender);
+// return "hello world";
+// }
+// }
+const abiJSON = `[ { "constant": false, "inputs": [ { "name": "memo", "type": "bytes" } ], "name": "receive", "outputs": [ { "name": "res", "type": "string" } ], "payable": true, "stateMutability": "payable", "type": "function" }, { "anonymous": false, "inputs": [ { "indexed": false, "name": "sender", "type": "address" }, { "indexed": false, "name": "amount", "type": "uint256" }, { "indexed": false, "name": "memo", "type": "bytes" } ], "name": "received", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": false, "name": "sender", "type": "address" } ], "name": "receivedAddr", "type": "event" } ]`
+const abiBin = `0x608060405234801561001057600080fd5b506102a0806100206000396000f3fe60806040526004361061003b576000357c010000000000000000000000000000000000000000000000000000000090048063a69b6ed014610040575b600080fd5b6100b76004803603602081101561005657600080fd5b810190808035906020019064010000000081111561007357600080fd5b82018360208201111561008557600080fd5b803590602001918460018302840111640100000000831117156100a757600080fd5b9091929391929390505050610132565b6040518080602001828103825283818151815260200191508051906020019080838360005b838110156100f75780820151818401526020810190506100dc565b50505050905090810190601f1680156101245780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b60607f75fd880d39c1daf53b6547ab6cb59451fc6452d27caa90e5b6649dd8293b9eed33348585604051808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001848152602001806020018281038252848482818152602001925080828437600081840152601f19601f8201169050808301925050509550505050505060405180910390a17f46923992397eac56cf13058aced2a1871933622717e27b24eabc13bf9dd329c833604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390a16040805190810160405280600b81526020017f68656c6c6f20776f726c6400000000000000000000000000000000000000000081525090509291505056fea165627a7a72305820ff0c57dad254cfeda48c9cfb47f1353a558bccb4d1bc31da1dae69315772d29e0029`
+const deployedCode = `60806040526004361061003b576000357c010000000000000000000000000000000000000000000000000000000090048063a69b6ed014610040575b600080fd5b6100b76004803603602081101561005657600080fd5b810190808035906020019064010000000081111561007357600080fd5b82018360208201111561008557600080fd5b803590602001918460018302840111640100000000831117156100a757600080fd5b9091929391929390505050610132565b6040518080602001828103825283818151815260200191508051906020019080838360005b838110156100f75780820151818401526020810190506100dc565b50505050905090810190601f1680156101245780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b60607f75fd880d39c1daf53b6547ab6cb59451fc6452d27caa90e5b6649dd8293b9eed33348585604051808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001848152602001806020018281038252848482818152602001925080828437600081840152601f19601f8201169050808301925050509550505050505060405180910390a17f46923992397eac56cf13058aced2a1871933622717e27b24eabc13bf9dd329c833604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390a16040805190810160405280600b81526020017f68656c6c6f20776f726c6400000000000000000000000000000000000000000081525090509291505056fea165627a7a72305820ff0c57dad254cfeda48c9cfb47f1353a558bccb4d1bc31da1dae69315772d29e0029`
+
+// expected return value contains "hello world"
+var expectedReturn = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+
+func simTestBackend(testAddr common.Address) *SimulatedBackend {
+ return NewSimulatedBackend(
+ core.GenesisAlloc{
+ testAddr: {Balance: big.NewInt(10000000000000000)},
+ }, 10000000,
+ )
+}
+
+func TestNewSimulatedBackend(t *testing.T) {
+ testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
+ expectedBal := big.NewInt(10000000000000000)
+ sim := simTestBackend(testAddr)
+ defer sim.Close()
+
+ if sim.config != params.AllEthashProtocolChanges {
+ t.Errorf("expected sim config to equal params.AllEthashProtocolChanges, got %v", sim.config)
+ }
+
+ if sim.blockchain.Config() != params.AllEthashProtocolChanges {
+ t.Errorf("expected sim blockchain config to equal params.AllEthashProtocolChanges, got %v", sim.config)
+ }
+
+ stateDB, _ := sim.blockchain.State()
+ bal := stateDB.GetBalance(testAddr)
+ if bal.Cmp(expectedBal) != 0 {
+ t.Errorf("expected balance for test address not received. expected: %v actual: %v", expectedBal, bal)
+ }
+}
+
+func TestAdjustTime(t *testing.T) {
+ sim := NewSimulatedBackend(
+ core.GenesisAlloc{}, 10000000,
+ )
+ defer sim.Close()
+
+ prevTime := sim.pendingBlock.Time()
+ if err := sim.AdjustTime(time.Second); err != nil {
+ t.Error(err)
+ }
+ newTime := sim.pendingBlock.Time()
+
+ if newTime-prevTime != uint64(time.Second.Seconds()) {
+ t.Errorf("adjusted time not equal to a second. prev: %v, new: %v", prevTime, newTime)
+ }
+}
+
+func TestNewAdjustTimeFail(t *testing.T) {
+ testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
+ sim := simTestBackend(testAddr)
+
+ // Create tx and send
+ head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough
+ gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1))
+
+ tx := types.NewTransaction(0, testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil)
+ signedTx, err := types.SignTx(tx, types.HomesteadSigner{}, testKey)
+ if err != nil {
+ t.Errorf("could not sign tx: %v", err)
+ }
+ sim.SendTransaction(context.Background(), signedTx)
+ // AdjustTime should fail on non-empty block
+ if err := sim.AdjustTime(time.Second); err == nil {
+ t.Error("Expected adjust time to error on non-empty block")
+ }
+ sim.Commit()
+
+ prevTime := sim.pendingBlock.Time()
+ if err := sim.AdjustTime(time.Minute); err != nil {
+ t.Error(err)
+ }
+ newTime := sim.pendingBlock.Time()
+ if newTime-prevTime != uint64(time.Minute.Seconds()) {
+ t.Errorf("adjusted time not equal to a minute. prev: %v, new: %v", prevTime, newTime)
+ }
+ // Put a transaction after adjusting time
+ tx2 := types.NewTransaction(1, testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil)
+ signedTx2, err := types.SignTx(tx2, types.HomesteadSigner{}, testKey)
+ if err != nil {
+ t.Errorf("could not sign tx: %v", err)
+ }
+ sim.SendTransaction(context.Background(), signedTx2)
+ sim.Commit()
+ newTime = sim.pendingBlock.Time()
+ if newTime-prevTime >= uint64(time.Minute.Seconds()) {
+ t.Errorf("time adjusted, but shouldn't be: prev: %v, new: %v", prevTime, newTime)
+ }
+}
+
+func TestBalanceAt(t *testing.T) {
+ testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
+ expectedBal := big.NewInt(10000000000000000)
+ sim := simTestBackend(testAddr)
+ defer sim.Close()
+ bgCtx := context.Background()
+
+ bal, err := sim.BalanceAt(bgCtx, testAddr, nil)
+ if err != nil {
+ t.Error(err)
+ }
+
+ if bal.Cmp(expectedBal) != 0 {
+ t.Errorf("expected balance for test address not received. expected: %v actual: %v", expectedBal, bal)
+ }
+}
+
+func TestBlockByHash(t *testing.T) {
+ sim := NewSimulatedBackend(
+ core.GenesisAlloc{}, 10000000,
+ )
+ defer sim.Close()
+ bgCtx := context.Background()
+
+ block, err := sim.BlockByNumber(bgCtx, nil)
+ if err != nil {
+ t.Errorf("could not get recent block: %v", err)
+ }
+ blockByHash, err := sim.BlockByHash(bgCtx, block.Hash())
+ if err != nil {
+ t.Errorf("could not get recent block: %v", err)
+ }
+
+ if block.Hash() != blockByHash.Hash() {
+ t.Errorf("did not get expected block")
+ }
+}
+
+func TestBlockByNumber(t *testing.T) {
+ sim := NewSimulatedBackend(
+ core.GenesisAlloc{}, 10000000,
+ )
+ defer sim.Close()
+ bgCtx := context.Background()
+
+ block, err := sim.BlockByNumber(bgCtx, nil)
+ if err != nil {
+ t.Errorf("could not get recent block: %v", err)
+ }
+ if block.NumberU64() != 0 {
+ t.Errorf("did not get most recent block, instead got block number %v", block.NumberU64())
+ }
+
+ // create one block
+ sim.Commit()
+
+ block, err = sim.BlockByNumber(bgCtx, nil)
+ if err != nil {
+ t.Errorf("could not get recent block: %v", err)
+ }
+ if block.NumberU64() != 1 {
+ t.Errorf("did not get most recent block, instead got block number %v", block.NumberU64())
+ }
+
+ blockByNumber, err := sim.BlockByNumber(bgCtx, big.NewInt(1))
+ if err != nil {
+ t.Errorf("could not get block by number: %v", err)
+ }
+ if blockByNumber.Hash() != block.Hash() {
+ t.Errorf("did not get the same block with height of 1 as before")
+ }
+}
+
+func TestNonceAt(t *testing.T) {
+ testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
+
+ sim := simTestBackend(testAddr)
+ defer sim.Close()
+ bgCtx := context.Background()
+
+ nonce, err := sim.NonceAt(bgCtx, testAddr, big.NewInt(0))
+ if err != nil {
+ t.Errorf("could not get nonce for test addr: %v", err)
+ }
+
+ if nonce != uint64(0) {
+ t.Errorf("received incorrect nonce. expected 0, got %v", nonce)
+ }
+
+ // create a signed transaction to send
+ head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough
+ gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1))
+
+ tx := types.NewTransaction(nonce, testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil)
+ signedTx, err := types.SignTx(tx, types.HomesteadSigner{}, testKey)
+ if err != nil {
+ t.Errorf("could not sign tx: %v", err)
+ }
+
+ // send tx to simulated backend
+ err = sim.SendTransaction(bgCtx, signedTx)
+ if err != nil {
+ t.Errorf("could not add tx to pending block: %v", err)
+ }
+ sim.Commit()
+
+ newNonce, err := sim.NonceAt(bgCtx, testAddr, big.NewInt(1))
+ if err != nil {
+ t.Errorf("could not get nonce for test addr: %v", err)
+ }
+
+ if newNonce != nonce+uint64(1) {
+ t.Errorf("received incorrect nonce. expected 1, got %v", nonce)
+ }
+ // create some more blocks
+ sim.Commit()
+ // Check that we can get data for an older block/state
+ newNonce, err = sim.NonceAt(bgCtx, testAddr, big.NewInt(1))
+ if err != nil {
+ t.Fatalf("could not get nonce for test addr: %v", err)
+ }
+ if newNonce != nonce+uint64(1) {
+ t.Fatalf("received incorrect nonce. expected 1, got %v", nonce)
+ }
+}
+
+func TestSendTransaction(t *testing.T) {
+ testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
+
+ sim := simTestBackend(testAddr)
+ defer sim.Close()
+ bgCtx := context.Background()
+
+ // create a signed transaction to send
+ head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough
+ gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1))
+
+ tx := types.NewTransaction(uint64(0), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil)
+ signedTx, err := types.SignTx(tx, types.HomesteadSigner{}, testKey)
+ if err != nil {
+ t.Errorf("could not sign tx: %v", err)
+ }
+
+ // send tx to simulated backend
+ err = sim.SendTransaction(bgCtx, signedTx)
+ if err != nil {
+ t.Errorf("could not add tx to pending block: %v", err)
+ }
+ sim.Commit()
+
+ block, err := sim.BlockByNumber(bgCtx, big.NewInt(1))
+ if err != nil {
+ t.Errorf("could not get block at height 1: %v", err)
+ }
+
+ if signedTx.Hash() != block.Transactions()[0].Hash() {
+ t.Errorf("did not commit sent transaction. expected hash %v got hash %v", block.Transactions()[0].Hash(), signedTx.Hash())
+ }
+}
+
+func TestTransactionByHash(t *testing.T) {
+ testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
+
+ sim := NewSimulatedBackend(
+ core.GenesisAlloc{
+ testAddr: {Balance: big.NewInt(10000000000000000)},
+ }, 10000000,
+ )
+ defer sim.Close()
+ bgCtx := context.Background()
+
+ // create a signed transaction to send
+ head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough
+ gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1))
+
+ tx := types.NewTransaction(uint64(0), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil)
+ signedTx, err := types.SignTx(tx, types.HomesteadSigner{}, testKey)
+ if err != nil {
+ t.Errorf("could not sign tx: %v", err)
+ }
+
+ // send tx to simulated backend
+ err = sim.SendTransaction(bgCtx, signedTx)
+ if err != nil {
+ t.Errorf("could not add tx to pending block: %v", err)
+ }
+
+ // ensure tx is committed pending
+ receivedTx, pending, err := sim.TransactionByHash(bgCtx, signedTx.Hash())
+ if err != nil {
+ t.Errorf("could not get transaction by hash %v: %v", signedTx.Hash(), err)
+ }
+ if !pending {
+ t.Errorf("expected transaction to be in pending state")
+ }
+ if receivedTx.Hash() != signedTx.Hash() {
+ t.Errorf("did not received committed transaction. expected hash %v got hash %v", signedTx.Hash(), receivedTx.Hash())
+ }
+
+ sim.Commit()
+
+ // ensure tx is not and committed pending
+ receivedTx, pending, err = sim.TransactionByHash(bgCtx, signedTx.Hash())
+ if err != nil {
+ t.Errorf("could not get transaction by hash %v: %v", signedTx.Hash(), err)
+ }
+ if pending {
+ t.Errorf("expected transaction to not be in pending state")
+ }
+ if receivedTx.Hash() != signedTx.Hash() {
+ t.Errorf("did not received committed transaction. expected hash %v got hash %v", signedTx.Hash(), receivedTx.Hash())
+ }
+}
+
+func TestEstimateGas(t *testing.T) {
+ /*
+ pragma solidity ^0.6.4;
+ contract GasEstimation {
+ function PureRevert() public { revert(); }
+ function Revert() public { revert("revert reason");}
+ function OOG() public { for (uint i = 0; ; i++) {}}
+ function Assert() public { assert(false);}
+ function Valid() public {}
+ }*/
+ const contractAbi = "[{\"inputs\":[],\"name\":\"Assert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"OOG\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PureRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"Revert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"Valid\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"
+ const contractBin = "0x60806040523480156100115760006000fd5b50610017565b61016e806100266000396000f3fe60806040523480156100115760006000fd5b506004361061005c5760003560e01c806350f6fe3414610062578063aa8b1d301461006c578063b9b046f914610076578063d8b9839114610080578063e09fface1461008a5761005c565b60006000fd5b61006a610094565b005b6100746100ad565b005b61007e6100b5565b005b6100886100c2565b005b610092610135565b005b6000600090505b5b808060010191505061009b565b505b565b60006000fd5b565b600015156100bf57fe5b5b565b6040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252600d8152602001807f72657665727420726561736f6e0000000000000000000000000000000000000081526020015060200191505060405180910390fd5b565b5b56fea2646970667358221220345bbcbb1a5ecf22b53a78eaebf95f8ee0eceff6d10d4b9643495084d2ec934a64736f6c63430006040033"
+
+ key, _ := crypto.GenerateKey()
+ addr := crypto.PubkeyToAddress(key.PublicKey)
+ opts, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
+
+ sim := NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(params.Ether)}}, 10000000)
+ defer sim.Close()
+
+ parsed, _ := abi.JSON(strings.NewReader(contractAbi))
+ contractAddr, _, _, _ := bind.DeployContract(opts, parsed, common.FromHex(contractBin), sim)
+ sim.Commit()
+
+ var cases = []struct {
+ name string
+ message ethereum.CallMsg
+ expect uint64
+ expectError error
+ expectData interface{}
+ }{
+ {"plain transfer(valid)", ethereum.CallMsg{
+ From: addr,
+ To: &addr,
+ Gas: 0,
+ GasPrice: big.NewInt(0),
+ Value: big.NewInt(1),
+ Data: nil,
+ }, params.TxGas, nil, nil},
+
+ {"plain transfer(invalid)", ethereum.CallMsg{
+ From: addr,
+ To: &contractAddr,
+ Gas: 0,
+ GasPrice: big.NewInt(0),
+ Value: big.NewInt(1),
+ Data: nil,
+ }, 0, errors.New("execution reverted"), nil},
+
+ {"Revert", ethereum.CallMsg{
+ From: addr,
+ To: &contractAddr,
+ Gas: 0,
+ GasPrice: big.NewInt(0),
+ Value: nil,
+ Data: common.Hex2Bytes("d8b98391"),
+ }, 0, errors.New("execution reverted: revert reason"), "0x08c379a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000d72657665727420726561736f6e00000000000000000000000000000000000000"},
+
+ {"PureRevert", ethereum.CallMsg{
+ From: addr,
+ To: &contractAddr,
+ Gas: 0,
+ GasPrice: big.NewInt(0),
+ Value: nil,
+ Data: common.Hex2Bytes("aa8b1d30"),
+ }, 0, errors.New("execution reverted"), nil},
+
+ {"OOG", ethereum.CallMsg{
+ From: addr,
+ To: &contractAddr,
+ Gas: 100000,
+ GasPrice: big.NewInt(0),
+ Value: nil,
+ Data: common.Hex2Bytes("50f6fe34"),
+ }, 0, errors.New("gas required exceeds allowance (100000)"), nil},
+
+ {"Assert", ethereum.CallMsg{
+ From: addr,
+ To: &contractAddr,
+ Gas: 100000,
+ GasPrice: big.NewInt(0),
+ Value: nil,
+ Data: common.Hex2Bytes("b9b046f9"),
+ }, 0, errors.New("invalid opcode: INVALID"), nil},
+
+ {"Valid", ethereum.CallMsg{
+ From: addr,
+ To: &contractAddr,
+ Gas: 100000,
+ GasPrice: big.NewInt(0),
+ Value: nil,
+ Data: common.Hex2Bytes("e09fface"),
+ }, 21275, nil, nil},
+ }
+ for _, c := range cases {
+ got, err := sim.EstimateGas(context.Background(), c.message)
+ if c.expectError != nil {
+ if err == nil {
+ t.Fatalf("Expect error, got nil")
+ }
+ if c.expectError.Error() != err.Error() {
+ t.Fatalf("Expect error, want %v, got %v", c.expectError, err)
+ }
+ if c.expectData != nil {
+ if err, ok := err.(*revertError); !ok {
+ t.Fatalf("Expect revert error, got %T", err)
+ } else if !reflect.DeepEqual(err.ErrorData(), c.expectData) {
+ t.Fatalf("Error data mismatch, want %v, got %v", c.expectData, err.ErrorData())
+ }
+ }
+ continue
+ }
+ if got != c.expect {
+ t.Fatalf("Gas estimation mismatch, want %d, got %d", c.expect, got)
+ }
+ }
+}
+
+func TestEstimateGasWithPrice(t *testing.T) {
+ key, _ := crypto.GenerateKey()
+ addr := crypto.PubkeyToAddress(key.PublicKey)
+
+ sim := NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(params.Ether*2 + 2e17)}}, 10000000)
+ defer sim.Close()
+
+ recipient := common.HexToAddress("deadbeef")
+ var cases = []struct {
+ name string
+ message ethereum.CallMsg
+ expect uint64
+ expectError error
+ }{
+ {"EstimateWithoutPrice", ethereum.CallMsg{
+ From: addr,
+ To: &recipient,
+ Gas: 0,
+ GasPrice: big.NewInt(0),
+ Value: big.NewInt(100000000000),
+ Data: nil,
+ }, 21000, nil},
+
+ {"EstimateWithPrice", ethereum.CallMsg{
+ From: addr,
+ To: &recipient,
+ Gas: 0,
+ GasPrice: big.NewInt(100000000000),
+ Value: big.NewInt(100000000000),
+ Data: nil,
+ }, 21000, nil},
+
+ {"EstimateWithVeryHighPrice", ethereum.CallMsg{
+ From: addr,
+ To: &recipient,
+ Gas: 0,
+ GasPrice: big.NewInt(1e14), // gascost = 2.1ether
+ Value: big.NewInt(1e17), // the remaining balance for fee is 2.1ether
+ Data: nil,
+ }, 21000, nil},
+
+ {"EstimateWithSuperhighPrice", ethereum.CallMsg{
+ From: addr,
+ To: &recipient,
+ Gas: 0,
+ GasPrice: big.NewInt(2e14), // gascost = 4.2ether
+ Value: big.NewInt(100000000000),
+ Data: nil,
+ }, 21000, errors.New("gas required exceeds allowance (10999)")}, // 10999=(2.2ether-1000wei)/(2e14)
+
+ {"EstimateEIP1559WithHighFees", ethereum.CallMsg{
+ From: addr,
+ To: &addr,
+ Gas: 0,
+ GasFeeCap: big.NewInt(1e14), // maxgascost = 2.1ether
+ GasTipCap: big.NewInt(1),
+ Value: big.NewInt(1e17), // the remaining balance for fee is 2.1ether
+ Data: nil,
+ }, params.TxGas, nil},
+
+ {"EstimateEIP1559WithSuperHighFees", ethereum.CallMsg{
+ From: addr,
+ To: &addr,
+ Gas: 0,
+ GasFeeCap: big.NewInt(1e14), // maxgascost = 2.1ether
+ GasTipCap: big.NewInt(1),
+ Value: big.NewInt(1e17 + 1), // the remaining balance for fee is 2.1ether
+ Data: nil,
+ }, params.TxGas, errors.New("gas required exceeds allowance (20999)")}, // 20999=(2.2ether-0.1ether-1wei)/(1e14)
+ }
+ for i, c := range cases {
+ got, err := sim.EstimateGas(context.Background(), c.message)
+ if c.expectError != nil {
+ if err == nil {
+ t.Fatalf("test %d: expect error, got nil", i)
+ }
+ if c.expectError.Error() != err.Error() {
+ t.Fatalf("test %d: expect error, want %v, got %v", i, c.expectError, err)
+ }
+ continue
+ }
+ if c.expectError == nil && err != nil {
+ t.Fatalf("test %d: didn't expect error, got %v", i, err)
+ }
+ if got != c.expect {
+ t.Fatalf("test %d: gas estimation mismatch, want %d, got %d", i, c.expect, got)
+ }
+ }
+}
+
+func TestHeaderByHash(t *testing.T) {
+ testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
+
+ sim := simTestBackend(testAddr)
+ defer sim.Close()
+ bgCtx := context.Background()
+
+ header, err := sim.HeaderByNumber(bgCtx, nil)
+ if err != nil {
+ t.Errorf("could not get recent block: %v", err)
+ }
+ headerByHash, err := sim.HeaderByHash(bgCtx, header.Hash())
+ if err != nil {
+ t.Errorf("could not get recent block: %v", err)
+ }
+
+ if header.Hash() != headerByHash.Hash() {
+ t.Errorf("did not get expected block")
+ }
+}
+
+func TestHeaderByNumber(t *testing.T) {
+ testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
+
+ sim := simTestBackend(testAddr)
+ defer sim.Close()
+ bgCtx := context.Background()
+
+ latestBlockHeader, err := sim.HeaderByNumber(bgCtx, nil)
+ if err != nil {
+ t.Errorf("could not get header for tip of chain: %v", err)
+ }
+ if latestBlockHeader == nil {
+ t.Errorf("received a nil block header")
+ } else if latestBlockHeader.Number.Uint64() != uint64(0) {
+ t.Errorf("expected block header number 0, instead got %v", latestBlockHeader.Number.Uint64())
+ }
+
+ sim.Commit()
+
+ latestBlockHeader, err = sim.HeaderByNumber(bgCtx, nil)
+ if err != nil {
+ t.Errorf("could not get header for blockheight of 1: %v", err)
+ }
+
+ blockHeader, err := sim.HeaderByNumber(bgCtx, big.NewInt(1))
+ if err != nil {
+ t.Errorf("could not get header for blockheight of 1: %v", err)
+ }
+
+ if blockHeader.Hash() != latestBlockHeader.Hash() {
+ t.Errorf("block header and latest block header are not the same")
+ }
+ if blockHeader.Number.Int64() != int64(1) {
+ t.Errorf("did not get blockheader for block 1. instead got block %v", blockHeader.Number.Int64())
+ }
+
+ block, err := sim.BlockByNumber(bgCtx, big.NewInt(1))
+ if err != nil {
+ t.Errorf("could not get block for blockheight of 1: %v", err)
+ }
+
+ if block.Hash() != blockHeader.Hash() {
+ t.Errorf("block hash and block header hash do not match. expected %v, got %v", block.Hash(), blockHeader.Hash())
+ }
+}
+
+func TestTransactionCount(t *testing.T) {
+ testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
+
+ sim := simTestBackend(testAddr)
+ defer sim.Close()
+ bgCtx := context.Background()
+ currentBlock, err := sim.BlockByNumber(bgCtx, nil)
+ if err != nil || currentBlock == nil {
+ t.Error("could not get current block")
+ }
+
+ count, err := sim.TransactionCount(bgCtx, currentBlock.Hash())
+ if err != nil {
+ t.Error("could not get current block's transaction count")
+ }
+
+ if count != 0 {
+ t.Errorf("expected transaction count of %v does not match actual count of %v", 0, count)
+ }
+ // create a signed transaction to send
+ head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough
+ gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1))
+
+ tx := types.NewTransaction(uint64(0), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil)
+ signedTx, err := types.SignTx(tx, types.HomesteadSigner{}, testKey)
+ if err != nil {
+ t.Errorf("could not sign tx: %v", err)
+ }
+
+ // send tx to simulated backend
+ err = sim.SendTransaction(bgCtx, signedTx)
+ if err != nil {
+ t.Errorf("could not add tx to pending block: %v", err)
+ }
+
+ sim.Commit()
+
+ lastBlock, err := sim.BlockByNumber(bgCtx, nil)
+ if err != nil {
+ t.Errorf("could not get header for tip of chain: %v", err)
+ }
+
+ count, err = sim.TransactionCount(bgCtx, lastBlock.Hash())
+ if err != nil {
+ t.Error("could not get current block's transaction count")
+ }
+
+ if count != 1 {
+ t.Errorf("expected transaction count of %v does not match actual count of %v", 1, count)
+ }
+}
+
+func TestTransactionInBlock(t *testing.T) {
+ testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
+
+ sim := simTestBackend(testAddr)
+ defer sim.Close()
+ bgCtx := context.Background()
+
+ transaction, err := sim.TransactionInBlock(bgCtx, sim.pendingBlock.Hash(), uint(0))
+ if err == nil && err != errTransactionDoesNotExist {
+ t.Errorf("expected a transaction does not exist error to be received but received %v", err)
+ }
+ if transaction != nil {
+ t.Errorf("expected transaction to be nil but received %v", transaction)
+ }
+
+ // expect pending nonce to be 0 since account has not been used
+ pendingNonce, err := sim.PendingNonceAt(bgCtx, testAddr)
+ if err != nil {
+ t.Errorf("did not get the pending nonce: %v", err)
+ }
+
+ if pendingNonce != uint64(0) {
+ t.Errorf("expected pending nonce of 0 got %v", pendingNonce)
+ }
+ // create a signed transaction to send
+ head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough
+ gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1))
+
+ tx := types.NewTransaction(uint64(0), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil)
+ signedTx, err := types.SignTx(tx, types.HomesteadSigner{}, testKey)
+ if err != nil {
+ t.Errorf("could not sign tx: %v", err)
+ }
+
+ // send tx to simulated backend
+ err = sim.SendTransaction(bgCtx, signedTx)
+ if err != nil {
+ t.Errorf("could not add tx to pending block: %v", err)
+ }
+
+ sim.Commit()
+
+ lastBlock, err := sim.BlockByNumber(bgCtx, nil)
+ if err != nil {
+ t.Errorf("could not get header for tip of chain: %v", err)
+ }
+
+ transaction, err = sim.TransactionInBlock(bgCtx, lastBlock.Hash(), uint(1))
+ if err == nil && err != errTransactionDoesNotExist {
+ t.Errorf("expected a transaction does not exist error to be received but received %v", err)
+ }
+ if transaction != nil {
+ t.Errorf("expected transaction to be nil but received %v", transaction)
+ }
+
+ transaction, err = sim.TransactionInBlock(bgCtx, lastBlock.Hash(), uint(0))
+ if err != nil {
+ t.Errorf("could not get transaction in the lastest block with hash %v: %v", lastBlock.Hash().String(), err)
+ }
+
+ if signedTx.Hash().String() != transaction.Hash().String() {
+ t.Errorf("received transaction that did not match the sent transaction. expected hash %v, got hash %v", signedTx.Hash().String(), transaction.Hash().String())
+ }
+}
+
+func TestPendingNonceAt(t *testing.T) {
+ testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
+
+ sim := simTestBackend(testAddr)
+ defer sim.Close()
+ bgCtx := context.Background()
+
+ // expect pending nonce to be 0 since account has not been used
+ pendingNonce, err := sim.PendingNonceAt(bgCtx, testAddr)
+ if err != nil {
+ t.Errorf("did not get the pending nonce: %v", err)
+ }
+
+ if pendingNonce != uint64(0) {
+ t.Errorf("expected pending nonce of 0 got %v", pendingNonce)
+ }
+
+ // create a signed transaction to send
+ head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough
+ gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1))
+
+ tx := types.NewTransaction(uint64(0), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil)
+ signedTx, err := types.SignTx(tx, types.HomesteadSigner{}, testKey)
+ if err != nil {
+ t.Errorf("could not sign tx: %v", err)
+ }
+
+ // send tx to simulated backend
+ err = sim.SendTransaction(bgCtx, signedTx)
+ if err != nil {
+ t.Errorf("could not add tx to pending block: %v", err)
+ }
+
+ // expect pending nonce to be 1 since account has submitted one transaction
+ pendingNonce, err = sim.PendingNonceAt(bgCtx, testAddr)
+ if err != nil {
+ t.Errorf("did not get the pending nonce: %v", err)
+ }
+
+ if pendingNonce != uint64(1) {
+ t.Errorf("expected pending nonce of 1 got %v", pendingNonce)
+ }
+
+ // make a new transaction with a nonce of 1
+ tx = types.NewTransaction(uint64(1), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil)
+ signedTx, err = types.SignTx(tx, types.HomesteadSigner{}, testKey)
+ if err != nil {
+ t.Errorf("could not sign tx: %v", err)
+ }
+ err = sim.SendTransaction(bgCtx, signedTx)
+ if err != nil {
+ t.Errorf("could not send tx: %v", err)
+ }
+
+ // expect pending nonce to be 2 since account now has two transactions
+ pendingNonce, err = sim.PendingNonceAt(bgCtx, testAddr)
+ if err != nil {
+ t.Errorf("did not get the pending nonce: %v", err)
+ }
+
+ if pendingNonce != uint64(2) {
+ t.Errorf("expected pending nonce of 2 got %v", pendingNonce)
+ }
+}
+
+func TestTransactionReceipt(t *testing.T) {
+ testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
+
+ sim := simTestBackend(testAddr)
+ defer sim.Close()
+ bgCtx := context.Background()
+
+ // create a signed transaction to send
+ head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough
+ gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1))
+
+ tx := types.NewTransaction(uint64(0), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil)
+ signedTx, err := types.SignTx(tx, types.HomesteadSigner{}, testKey)
+ if err != nil {
+ t.Errorf("could not sign tx: %v", err)
+ }
+
+ // send tx to simulated backend
+ err = sim.SendTransaction(bgCtx, signedTx)
+ if err != nil {
+ t.Errorf("could not add tx to pending block: %v", err)
+ }
+ sim.Commit()
+
+ receipt, err := sim.TransactionReceipt(bgCtx, signedTx.Hash())
+ if err != nil {
+ t.Errorf("could not get transaction receipt: %v", err)
+ }
+
+ if receipt.ContractAddress != testAddr && receipt.TxHash != signedTx.Hash() {
+ t.Errorf("received receipt is not correct: %v", receipt)
+ }
+}
+
+func TestSuggestGasPrice(t *testing.T) {
+ sim := NewSimulatedBackend(
+ core.GenesisAlloc{},
+ 10000000,
+ )
+ defer sim.Close()
+ bgCtx := context.Background()
+ gasPrice, err := sim.SuggestGasPrice(bgCtx)
+ if err != nil {
+ t.Errorf("could not get gas price: %v", err)
+ }
+ if gasPrice.Uint64() != sim.pendingBlock.Header().BaseFee.Uint64() {
+ t.Errorf("gas price was not expected value of %v. actual: %v", sim.pendingBlock.Header().BaseFee.Uint64(), gasPrice.Uint64())
+ }
+}
+
+func TestPendingCodeAt(t *testing.T) {
+ testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
+ sim := simTestBackend(testAddr)
+ defer sim.Close()
+ bgCtx := context.Background()
+ code, err := sim.CodeAt(bgCtx, testAddr, nil)
+ if err != nil {
+ t.Errorf("could not get code at test addr: %v", err)
+ }
+ if len(code) != 0 {
+ t.Errorf("got code for account that does not have contract code")
+ }
+
+ parsed, err := abi.JSON(strings.NewReader(abiJSON))
+ if err != nil {
+ t.Errorf("could not get code at test addr: %v", err)
+ }
+ auth, _ := bind.NewKeyedTransactorWithChainID(testKey, big.NewInt(1337))
+ contractAddr, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(abiBin), sim)
+ if err != nil {
+ t.Errorf("could not deploy contract: %v tx: %v contract: %v", err, tx, contract)
+ }
+
+ code, err = sim.PendingCodeAt(bgCtx, contractAddr)
+ if err != nil {
+ t.Errorf("could not get code at test addr: %v", err)
+ }
+ if len(code) == 0 {
+ t.Errorf("did not get code for account that has contract code")
+ }
+ // ensure code received equals code deployed
+ if !bytes.Equal(code, common.FromHex(deployedCode)) {
+ t.Errorf("code received did not match expected deployed code:\n expected %v\n actual %v", common.FromHex(deployedCode), code)
+ }
+}
+
+func TestCodeAt(t *testing.T) {
+ testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
+ sim := simTestBackend(testAddr)
+ defer sim.Close()
+ bgCtx := context.Background()
+ code, err := sim.CodeAt(bgCtx, testAddr, nil)
+ if err != nil {
+ t.Errorf("could not get code at test addr: %v", err)
+ }
+ if len(code) != 0 {
+ t.Errorf("got code for account that does not have contract code")
+ }
+
+ parsed, err := abi.JSON(strings.NewReader(abiJSON))
+ if err != nil {
+ t.Errorf("could not get code at test addr: %v", err)
+ }
+ auth, _ := bind.NewKeyedTransactorWithChainID(testKey, big.NewInt(1337))
+ contractAddr, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(abiBin), sim)
+ if err != nil {
+ t.Errorf("could not deploy contract: %v tx: %v contract: %v", err, tx, contract)
+ }
+
+ sim.Commit()
+ code, err = sim.CodeAt(bgCtx, contractAddr, nil)
+ if err != nil {
+ t.Errorf("could not get code at test addr: %v", err)
+ }
+ if len(code) == 0 {
+ t.Errorf("did not get code for account that has contract code")
+ }
+ // ensure code received equals code deployed
+ if !bytes.Equal(code, common.FromHex(deployedCode)) {
+ t.Errorf("code received did not match expected deployed code:\n expected %v\n actual %v", common.FromHex(deployedCode), code)
+ }
+}
+
+// When receive("X") is called with sender 0x00... and value 1, it produces this tx receipt:
+// receipt{status=1 cgas=23949 bloom=00000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000040200000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 logs=[log: b6818c8064f645cd82d99b59a1a267d6d61117ef [75fd880d39c1daf53b6547ab6cb59451fc6452d27caa90e5b6649dd8293b9eed] 000000000000000000000000376c47978271565f56deb45495afa69e59c16ab200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158 9ae378b6d4409eada347a5dc0c180f186cb62dc68fcc0f043425eb917335aa28 0 95d429d309bb9d753954195fe2d69bd140b4ae731b9b5b605c34323de162cf00 0]}
+func TestPendingAndCallContract(t *testing.T) {
+ testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
+ sim := simTestBackend(testAddr)
+ defer sim.Close()
+ bgCtx := context.Background()
+
+ parsed, err := abi.JSON(strings.NewReader(abiJSON))
+ if err != nil {
+ t.Errorf("could not get code at test addr: %v", err)
+ }
+ contractAuth, _ := bind.NewKeyedTransactorWithChainID(testKey, big.NewInt(1337))
+ addr, _, _, err := bind.DeployContract(contractAuth, parsed, common.FromHex(abiBin), sim)
+ if err != nil {
+ t.Errorf("could not deploy contract: %v", err)
+ }
+
+ input, err := parsed.Pack("receive", []byte("X"))
+ if err != nil {
+ t.Errorf("could not pack receive function on contract: %v", err)
+ }
+
+ // make sure you can call the contract in pending state
+ res, err := sim.PendingCallContract(bgCtx, ethereum.CallMsg{
+ From: testAddr,
+ To: &addr,
+ Data: input,
+ })
+ if err != nil {
+ t.Errorf("could not call receive method on contract: %v", err)
+ }
+ if len(res) == 0 {
+ t.Errorf("result of contract call was empty: %v", res)
+ }
+
+ // while comparing against the byte array is more exact, also compare against the human readable string for readability
+ if !bytes.Equal(res, expectedReturn) || !strings.Contains(string(res), "hello world") {
+ t.Errorf("response from calling contract was expected to be 'hello world' instead received %v", string(res))
+ }
+
+ sim.Commit()
+
+ // make sure you can call the contract
+ res, err = sim.CallContract(bgCtx, ethereum.CallMsg{
+ From: testAddr,
+ To: &addr,
+ Data: input,
+ }, nil)
+ if err != nil {
+ t.Errorf("could not call receive method on contract: %v", err)
+ }
+ if len(res) == 0 {
+ t.Errorf("result of contract call was empty: %v", res)
+ }
+
+ if !bytes.Equal(res, expectedReturn) || !strings.Contains(string(res), "hello world") {
+ t.Errorf("response from calling contract was expected to be 'hello world' instead received %v", string(res))
+ }
+}
+
+// This test is based on the following contract:
+/*
+contract Reverter {
+ function revertString() public pure{
+ require(false, "some error");
+ }
+ function revertNoString() public pure {
+ require(false, "");
+ }
+ function revertASM() public pure {
+ assembly {
+ revert(0x0, 0x0)
+ }
+ }
+ function noRevert() public pure {
+ assembly {
+ // Assembles something that looks like require(false, "some error") but is not reverted
+ mstore(0x0, 0x08c379a000000000000000000000000000000000000000000000000000000000)
+ mstore(0x4, 0x0000000000000000000000000000000000000000000000000000000000000020)
+ mstore(0x24, 0x000000000000000000000000000000000000000000000000000000000000000a)
+ mstore(0x44, 0x736f6d65206572726f7200000000000000000000000000000000000000000000)
+ return(0x0, 0x64)
+ }
+ }
+}*/
+func TestCallContractRevert(t *testing.T) {
+ testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
+ sim := simTestBackend(testAddr)
+ defer sim.Close()
+ bgCtx := context.Background()
+
+ reverterABI := `[{"inputs": [],"name": "noRevert","outputs": [],"stateMutability": "pure","type": "function"},{"inputs": [],"name": "revertASM","outputs": [],"stateMutability": "pure","type": "function"},{"inputs": [],"name": "revertNoString","outputs": [],"stateMutability": "pure","type": "function"},{"inputs": [],"name": "revertString","outputs": [],"stateMutability": "pure","type": "function"}]`
+ reverterBin := "608060405234801561001057600080fd5b506101d3806100206000396000f3fe608060405234801561001057600080fd5b506004361061004c5760003560e01c80634b409e01146100515780639b340e361461005b5780639bd6103714610065578063b7246fc11461006f575b600080fd5b610059610079565b005b6100636100ca565b005b61006d6100cf565b005b610077610145565b005b60006100c8576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401808060200182810382526000815260200160200191505060405180910390fd5b565b600080fd5b6000610143576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252600a8152602001807f736f6d65206572726f720000000000000000000000000000000000000000000081525060200191505060405180910390fd5b565b7f08c379a0000000000000000000000000000000000000000000000000000000006000526020600452600a6024527f736f6d65206572726f720000000000000000000000000000000000000000000060445260646000f3fea2646970667358221220cdd8af0609ec4996b7360c7c780bad5c735740c64b1fffc3445aa12d37f07cb164736f6c63430006070033"
+
+ parsed, err := abi.JSON(strings.NewReader(reverterABI))
+ if err != nil {
+ t.Errorf("could not get code at test addr: %v", err)
+ }
+ contractAuth, _ := bind.NewKeyedTransactorWithChainID(testKey, big.NewInt(1337))
+ addr, _, _, err := bind.DeployContract(contractAuth, parsed, common.FromHex(reverterBin), sim)
+ if err != nil {
+ t.Errorf("could not deploy contract: %v", err)
+ }
+
+ inputs := make(map[string]interface{}, 3)
+ inputs["revertASM"] = nil
+ inputs["revertNoString"] = ""
+ inputs["revertString"] = "some error"
+
+ call := make([]func([]byte) ([]byte, error), 2)
+ call[0] = func(input []byte) ([]byte, error) {
+ return sim.PendingCallContract(bgCtx, ethereum.CallMsg{
+ From: testAddr,
+ To: &addr,
+ Data: input,
+ })
+ }
+ call[1] = func(input []byte) ([]byte, error) {
+ return sim.CallContract(bgCtx, ethereum.CallMsg{
+ From: testAddr,
+ To: &addr,
+ Data: input,
+ }, nil)
+ }
+
+ // Run pending calls then commit
+ for _, cl := range call {
+ for key, val := range inputs {
+ input, err := parsed.Pack(key)
+ if err != nil {
+ t.Errorf("could not pack %v function on contract: %v", key, err)
+ }
+
+ res, err := cl(input)
+ if err == nil {
+ t.Errorf("call to %v was not reverted", key)
+ }
+ if res != nil {
+ t.Errorf("result from %v was not nil: %v", key, res)
+ }
+ if val != nil {
+ rerr, ok := err.(*revertError)
+ if !ok {
+ t.Errorf("expect revert error")
+ }
+ if rerr.Error() != "execution reverted: "+val.(string) {
+ t.Errorf("error was malformed: got %v want %v", rerr.Error(), val)
+ }
+ } else {
+ // revert(0x0,0x0)
+ if err.Error() != "execution reverted" {
+ t.Errorf("error was malformed: got %v want %v", err, "execution reverted")
+ }
+ }
+ }
+ input, err := parsed.Pack("noRevert")
+ if err != nil {
+ t.Errorf("could not pack noRevert function on contract: %v", err)
+ }
+ res, err := cl(input)
+ if err != nil {
+ t.Error("call to noRevert was reverted")
+ }
+ if res == nil {
+ t.Errorf("result from noRevert was nil")
+ }
+ sim.Commit()
+ }
+}
+
+// TestFork check that the chain length after a reorg is correct.
+// Steps:
+// 1. Save the current block which will serve as parent for the fork.
+// 2. Mine n blocks with n ∈ [0, 20].
+// 3. Assert that the chain length is n.
+// 4. Fork by using the parent block as ancestor.
+// 5. Mine n+1 blocks which should trigger a reorg.
+// 6. Assert that the chain length is n+1.
+// Since Commit() was called 2n+1 times in total,
+// having a chain length of just n+1 means that a reorg occurred.
+func TestFork(t *testing.T) {
+ testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
+ sim := simTestBackend(testAddr)
+ defer sim.Close()
+ // 1.
+ parent := sim.blockchain.CurrentBlock()
+ // 2.
+ n := int(rand.Int31n(21))
+ for i := 0; i < n; i++ {
+ sim.Commit()
+ }
+ // 3.
+ if sim.blockchain.CurrentBlock().NumberU64() != uint64(n) {
+ t.Error("wrong chain length")
+ }
+ // 4.
+ sim.Fork(context.Background(), parent.Hash())
+ // 5.
+ for i := 0; i < n+1; i++ {
+ sim.Commit()
+ }
+ // 6.
+ if sim.blockchain.CurrentBlock().NumberU64() != uint64(n+1) {
+ t.Error("wrong chain length")
+ }
+}
+
+/*
+Example contract to test event emission:
+
+pragma solidity >=0.7.0 <0.9.0;
+contract Callable {
+ event Called();
+ function Call() public { emit Called(); }
+}
+*/
+const callableAbi = "[{\"anonymous\":false,\"inputs\":[],\"name\":\"Called\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"Call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"
+
+const callableBin = "6080604052348015600f57600080fd5b5060998061001e6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c806334e2292114602d575b600080fd5b60336035565b005b7f81fab7a4a0aa961db47eefc81f143a5220e8c8495260dd65b1356f1d19d3c7b860405160405180910390a156fea2646970667358221220029436d24f3ac598ceca41d4d712e13ced6d70727f4cdc580667de66d2f51d8b64736f6c63430008010033"
+
+// TestForkLogsReborn check that the simulated reorgs
+// correctly remove and reborn logs.
+// Steps:
+// 1. Deploy the Callable contract.
+// 2. Set up an event subscription.
+// 3. Save the current block which will serve as parent for the fork.
+// 4. Send a transaction.
+// 5. Check that the event was included.
+// 6. Fork by using the parent block as ancestor.
+// 7. Mine two blocks to trigger a reorg.
+// 8. Check that the event was removed.
+// 9. Re-send the transaction and mine a block.
+// 10. Check that the event was reborn.
+func TestForkLogsReborn(t *testing.T) {
+ testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
+ sim := simTestBackend(testAddr)
+ defer sim.Close()
+ // 1.
+ parsed, _ := abi.JSON(strings.NewReader(callableAbi))
+ auth, _ := bind.NewKeyedTransactorWithChainID(testKey, big.NewInt(1337))
+ _, _, contract, err := bind.DeployContract(auth, parsed, common.FromHex(callableBin), sim)
+ if err != nil {
+ t.Errorf("deploying contract: %v", err)
+ }
+ sim.Commit()
+ // 2.
+ logs, sub, err := contract.WatchLogs(nil, "Called")
+ if err != nil {
+ t.Errorf("watching logs: %v", err)
+ }
+ defer sub.Unsubscribe()
+ // 3.
+ parent := sim.blockchain.CurrentBlock()
+ // 4.
+ tx, err := contract.Transact(auth, "Call")
+ if err != nil {
+ t.Errorf("transacting: %v", err)
+ }
+ sim.Commit()
+ // 5.
+ log := <-logs
+ if log.TxHash != tx.Hash() {
+ t.Error("wrong event tx hash")
+ }
+ if log.Removed {
+ t.Error("Event should be included")
+ }
+ // 6.
+ if err := sim.Fork(context.Background(), parent.Hash()); err != nil {
+ t.Errorf("forking: %v", err)
+ }
+ // 7.
+ sim.Commit()
+ sim.Commit()
+ // 8.
+ log = <-logs
+ if log.TxHash != tx.Hash() {
+ t.Error("wrong event tx hash")
+ }
+ if !log.Removed {
+ t.Error("Event should be removed")
+ }
+ // 9.
+ if err := sim.SendTransaction(context.Background(), tx); err != nil {
+ t.Errorf("sending transaction: %v", err)
+ }
+ sim.Commit()
+ // 10.
+ log = <-logs
+ if log.TxHash != tx.Hash() {
+ t.Error("wrong event tx hash")
+ }
+ if log.Removed {
+ t.Error("Event should be included")
+ }
+}
+
+// TestForkResendTx checks that re-sending a TX after a fork
+// is possible and does not cause a "nonce mismatch" panic.
+// Steps:
+// 1. Save the current block which will serve as parent for the fork.
+// 2. Send a transaction.
+// 3. Check that the TX is included in block 1.
+// 4. Fork by using the parent block as ancestor.
+// 5. Mine a block, Re-send the transaction and mine another one.
+// 6. Check that the TX is now included in block 2.
+func TestForkResendTx(t *testing.T) {
+ testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
+ sim := simTestBackend(testAddr)
+ defer sim.Close()
+ // 1.
+ parent := sim.blockchain.CurrentBlock()
+ // 2.
+ head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough
+ gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1))
+
+ _tx := types.NewTransaction(0, testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil)
+ tx, _ := types.SignTx(_tx, types.HomesteadSigner{}, testKey)
+ sim.SendTransaction(context.Background(), tx)
+ sim.Commit()
+ // 3.
+ receipt, _ := sim.TransactionReceipt(context.Background(), tx.Hash())
+ if h := receipt.BlockNumber.Uint64(); h != 1 {
+ t.Errorf("TX included in wrong block: %d", h)
+ }
+ // 4.
+ if err := sim.Fork(context.Background(), parent.Hash()); err != nil {
+ t.Errorf("forking: %v", err)
+ }
+ // 5.
+ sim.Commit()
+ if err := sim.SendTransaction(context.Background(), tx); err != nil {
+ t.Errorf("sending transaction: %v", err)
+ }
+ sim.Commit()
+ // 6.
+ receipt, _ = sim.TransactionReceipt(context.Background(), tx.Hash())
+ if h := receipt.BlockNumber.Uint64(); h != 2 {
+ t.Errorf("TX included in wrong block: %d", h)
+ }
+}
diff --git a/abigen/accounts/abi/bind/base.go b/abigen/accounts/abi/bind/base.go
new file mode 100644
index 00000000..bca02a3c
--- /dev/null
+++ b/abigen/accounts/abi/bind/base.go
@@ -0,0 +1,530 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package bind
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "math/big"
+ "strings"
+ "sync"
+
+ "github.com/ethereum/go-ethereum"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/crypto"
+ "github.com/ethereum/go-ethereum/event"
+ "gitlab.com/alphaticks/abigen-starknet/accounts/abi"
+)
+
+// SignerFn is a signer function callback when a contract requires a method to
+// sign the transaction before submission.
+type SignerFn func(common.Address, *types.Transaction) (*types.Transaction, error)
+
+// CallOpts is the collection of options to fine tune a contract call request.
+type CallOpts struct {
+ Pending bool // Whether to operate on the pending state or the last known one
+ From common.Address // Optional the sender address, otherwise the first account is used
+ BlockNumber *big.Int // Optional the block number on which the call should be performed
+ Context context.Context // Network context to support cancellation and timeouts (nil = no timeout)
+}
+
+// TransactOpts is the collection of authorization data required to create a
+// valid Ethereum transaction.
+type TransactOpts struct {
+ From common.Address // Ethereum account to send the transaction from
+ Nonce *big.Int // Nonce to use for the transaction execution (nil = use pending state)
+ Signer SignerFn // Method to use for signing the transaction (mandatory)
+
+ Value *big.Int // Funds to transfer along the transaction (nil = 0 = no funds)
+ GasPrice *big.Int // Gas price to use for the transaction execution (nil = gas price oracle)
+ GasFeeCap *big.Int // Gas fee cap to use for the 1559 transaction execution (nil = gas price oracle)
+ GasTipCap *big.Int // Gas priority fee cap to use for the 1559 transaction execution (nil = gas price oracle)
+ GasLimit uint64 // Gas limit to set for the transaction execution (0 = estimate)
+
+ Context context.Context // Network context to support cancellation and timeouts (nil = no timeout)
+
+ NoSend bool // Do all transact steps but do not send the transaction
+}
+
+// FilterOpts is the collection of options to fine tune filtering for events
+// within a bound contract.
+type FilterOpts struct {
+ Start uint64 // Start of the queried range
+ End *uint64 // End of the range (nil = latest)
+
+ Context context.Context // Network context to support cancellation and timeouts (nil = no timeout)
+}
+
+// WatchOpts is the collection of options to fine tune subscribing for events
+// within a bound contract.
+type WatchOpts struct {
+ Start *uint64 // Start of the queried range (nil = latest)
+ Context context.Context // Network context to support cancellation and timeouts (nil = no timeout)
+}
+
+// MetaData collects all metadata for a bound contract.
+type MetaData struct {
+ mu sync.Mutex
+ Sigs map[string]string
+ Bin string
+ ABI string
+ ab *abi.ABI
+}
+
+func (m *MetaData) GetAbi() (*abi.ABI, error) {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ if m.ab != nil {
+ return m.ab, nil
+ }
+ if parsed, err := abi.JSON(strings.NewReader(m.ABI)); err != nil {
+ return nil, err
+ } else {
+ m.ab = &parsed
+ }
+ return m.ab, nil
+}
+
+// BoundContract is the base wrapper object that reflects a contract on the
+// Ethereum network. It contains a collection of methods that are used by the
+// higher level contract bindings to operate.
+type BoundContract struct {
+ address common.Address // Deployment address of the contract on the Ethereum blockchain
+ abi abi.ABI // Reflect based ABI to access the correct Ethereum methods
+ caller ContractCaller // Read interface to interact with the blockchain
+ transactor ContractTransactor // Write interface to interact with the blockchain
+ filterer ContractFilterer // Event filtering to interact with the blockchain
+}
+
+// NewBoundContract creates a low level contract interface through which calls
+// and transactions may be made through.
+func NewBoundContract(address common.Address, abi abi.ABI, caller ContractCaller, transactor ContractTransactor, filterer ContractFilterer) *BoundContract {
+ return &BoundContract{
+ address: address,
+ abi: abi,
+ caller: caller,
+ transactor: transactor,
+ filterer: filterer,
+ }
+}
+
+// DeployContract deploys a contract onto the Ethereum blockchain and binds the
+// deployment address with a Go wrapper.
+func DeployContract(opts *TransactOpts, abi abi.ABI, bytecode []byte, backend ContractBackend, params ...interface{}) (common.Address, *types.Transaction, *BoundContract, error) {
+ // Otherwise try to deploy the contract
+ c := NewBoundContract(common.Address{}, abi, backend, backend, backend)
+
+ input, err := c.abi.Pack("", params...)
+ if err != nil {
+ return common.Address{}, nil, nil, err
+ }
+ tx, err := c.transact(opts, nil, append(bytecode, input...))
+ if err != nil {
+ return common.Address{}, nil, nil, err
+ }
+ c.address = crypto.CreateAddress(opts.From, tx.Nonce())
+ return c.address, tx, c, nil
+}
+
+// Call invokes the (constant) contract method with params as input values and
+// sets the output to result. The result type might be a single field for simple
+// returns, a slice of interfaces for anonymous returns and a struct for named
+// returns.
+func (c *BoundContract) Call(opts *CallOpts, results *[]interface{}, method string, params ...interface{}) error {
+ // Don't crash on a lazy user
+ if opts == nil {
+ opts = new(CallOpts)
+ }
+ if results == nil {
+ results = new([]interface{})
+ }
+ // Pack the input, call and unpack the results
+ input, err := c.abi.Pack(method, params...)
+ if err != nil {
+ return err
+ }
+ var (
+ msg = ethereum.CallMsg{From: opts.From, To: &c.address, Data: input}
+ ctx = ensureContext(opts.Context)
+ code []byte
+ output []byte
+ )
+ if opts.Pending {
+ pb, ok := c.caller.(PendingContractCaller)
+ if !ok {
+ return ErrNoPendingState
+ }
+ output, err = pb.PendingCallContract(ctx, msg)
+ if err != nil {
+ return err
+ }
+ if len(output) == 0 {
+ // Make sure we have a contract to operate on, and bail out otherwise.
+ if code, err = pb.PendingCodeAt(ctx, c.address); err != nil {
+ return err
+ } else if len(code) == 0 {
+ return ErrNoCode
+ }
+ }
+ } else {
+ output, err = c.caller.CallContract(ctx, msg, opts.BlockNumber)
+ if err != nil {
+ return err
+ }
+ if len(output) == 0 {
+ // Make sure we have a contract to operate on, and bail out otherwise.
+ if code, err = c.caller.CodeAt(ctx, c.address, opts.BlockNumber); err != nil {
+ return err
+ } else if len(code) == 0 {
+ return ErrNoCode
+ }
+ }
+ }
+
+ if len(*results) == 0 {
+ res, err := c.abi.Unpack(method, output)
+ *results = res
+ return err
+ }
+ res := *results
+ return c.abi.UnpackIntoInterface(res[0], method, output)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (c *BoundContract) Transact(opts *TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+ // Otherwise pack up the parameters and invoke the contract
+ input, err := c.abi.Pack(method, params...)
+ if err != nil {
+ return nil, err
+ }
+ // todo(rjl493456442) check the method is payable or not,
+ // reject invalid transaction at the first place
+ return c.transact(opts, &c.address, input)
+}
+
+// RawTransact initiates a transaction with the given raw calldata as the input.
+// It's usually used to initiate transactions for invoking **Fallback** function.
+func (c *BoundContract) RawTransact(opts *TransactOpts, calldata []byte) (*types.Transaction, error) {
+ // todo(rjl493456442) check the method is payable or not,
+ // reject invalid transaction at the first place
+ return c.transact(opts, &c.address, calldata)
+}
+
+// Transfer initiates a plain transaction to move funds to the contract, calling
+// its default method if one is available.
+func (c *BoundContract) Transfer(opts *TransactOpts) (*types.Transaction, error) {
+ // todo(rjl493456442) check the payable fallback or receive is defined
+ // or not, reject invalid transaction at the first place
+ return c.transact(opts, &c.address, nil)
+}
+
+func (c *BoundContract) createDynamicTx(opts *TransactOpts, contract *common.Address, input []byte, head *types.Header) (*types.Transaction, error) {
+ // Normalize value
+ value := opts.Value
+ if value == nil {
+ value = new(big.Int)
+ }
+ // Estimate TipCap
+ gasTipCap := opts.GasTipCap
+ if gasTipCap == nil {
+ tip, err := c.transactor.SuggestGasTipCap(ensureContext(opts.Context))
+ if err != nil {
+ return nil, err
+ }
+ gasTipCap = tip
+ }
+ // Estimate FeeCap
+ gasFeeCap := opts.GasFeeCap
+ if gasFeeCap == nil {
+ gasFeeCap = new(big.Int).Add(
+ gasTipCap,
+ new(big.Int).Mul(head.BaseFee, big.NewInt(2)),
+ )
+ }
+ if gasFeeCap.Cmp(gasTipCap) < 0 {
+ return nil, fmt.Errorf("maxFeePerGas (%v) < maxPriorityFeePerGas (%v)", gasFeeCap, gasTipCap)
+ }
+ // Estimate GasLimit
+ gasLimit := opts.GasLimit
+ if opts.GasLimit == 0 {
+ var err error
+ gasLimit, err = c.estimateGasLimit(opts, contract, input, nil, gasTipCap, gasFeeCap, value)
+ if err != nil {
+ return nil, err
+ }
+ }
+ // create the transaction
+ nonce, err := c.getNonce(opts)
+ if err != nil {
+ return nil, err
+ }
+ baseTx := &types.DynamicFeeTx{
+ To: contract,
+ Nonce: nonce,
+ GasFeeCap: gasFeeCap,
+ GasTipCap: gasTipCap,
+ Gas: gasLimit,
+ Value: value,
+ Data: input,
+ }
+ return types.NewTx(baseTx), nil
+}
+
+func (c *BoundContract) createLegacyTx(opts *TransactOpts, contract *common.Address, input []byte) (*types.Transaction, error) {
+ if opts.GasFeeCap != nil || opts.GasTipCap != nil {
+ return nil, errors.New("maxFeePerGas or maxPriorityFeePerGas specified but london is not active yet")
+ }
+ // Normalize value
+ value := opts.Value
+ if value == nil {
+ value = new(big.Int)
+ }
+ // Estimate GasPrice
+ gasPrice := opts.GasPrice
+ if gasPrice == nil {
+ price, err := c.transactor.SuggestGasPrice(ensureContext(opts.Context))
+ if err != nil {
+ return nil, err
+ }
+ gasPrice = price
+ }
+ // Estimate GasLimit
+ gasLimit := opts.GasLimit
+ if opts.GasLimit == 0 {
+ var err error
+ gasLimit, err = c.estimateGasLimit(opts, contract, input, gasPrice, nil, nil, value)
+ if err != nil {
+ return nil, err
+ }
+ }
+ // create the transaction
+ nonce, err := c.getNonce(opts)
+ if err != nil {
+ return nil, err
+ }
+ baseTx := &types.LegacyTx{
+ To: contract,
+ Nonce: nonce,
+ GasPrice: gasPrice,
+ Gas: gasLimit,
+ Value: value,
+ Data: input,
+ }
+ return types.NewTx(baseTx), nil
+}
+
+func (c *BoundContract) estimateGasLimit(opts *TransactOpts, contract *common.Address, input []byte, gasPrice, gasTipCap, gasFeeCap, value *big.Int) (uint64, error) {
+ if contract != nil {
+ // Gas estimation cannot succeed without code for method invocations.
+ if code, err := c.transactor.PendingCodeAt(ensureContext(opts.Context), c.address); err != nil {
+ return 0, err
+ } else if len(code) == 0 {
+ return 0, ErrNoCode
+ }
+ }
+ msg := ethereum.CallMsg{
+ From: opts.From,
+ To: contract,
+ GasPrice: gasPrice,
+ GasTipCap: gasTipCap,
+ GasFeeCap: gasFeeCap,
+ Value: value,
+ Data: input,
+ }
+ return c.transactor.EstimateGas(ensureContext(opts.Context), msg)
+}
+
+func (c *BoundContract) getNonce(opts *TransactOpts) (uint64, error) {
+ if opts.Nonce == nil {
+ return c.transactor.PendingNonceAt(ensureContext(opts.Context), opts.From)
+ } else {
+ return opts.Nonce.Uint64(), nil
+ }
+}
+
+// transact executes an actual transaction invocation, first deriving any missing
+// authorization fields, and then scheduling the transaction for execution.
+func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, input []byte) (*types.Transaction, error) {
+ if opts.GasPrice != nil && (opts.GasFeeCap != nil || opts.GasTipCap != nil) {
+ return nil, errors.New("both gasPrice and (maxFeePerGas or maxPriorityFeePerGas) specified")
+ }
+ // Create the transaction
+ var (
+ rawTx *types.Transaction
+ err error
+ )
+ if opts.GasPrice != nil {
+ rawTx, err = c.createLegacyTx(opts, contract, input)
+ } else {
+ // Only query for basefee if gasPrice not specified
+ if head, errHead := c.transactor.HeaderByNumber(ensureContext(opts.Context), nil); errHead != nil {
+ return nil, errHead
+ } else if head.BaseFee != nil {
+ rawTx, err = c.createDynamicTx(opts, contract, input, head)
+ } else {
+ // Chain is not London ready -> use legacy transaction
+ rawTx, err = c.createLegacyTx(opts, contract, input)
+ }
+ }
+ if err != nil {
+ return nil, err
+ }
+ // Sign the transaction and schedule it for execution
+ if opts.Signer == nil {
+ return nil, errors.New("no signer to authorize the transaction with")
+ }
+ signedTx, err := opts.Signer(opts.From, rawTx)
+ if err != nil {
+ return nil, err
+ }
+ if opts.NoSend {
+ return signedTx, nil
+ }
+ if err := c.transactor.SendTransaction(ensureContext(opts.Context), signedTx); err != nil {
+ return nil, err
+ }
+ return signedTx, nil
+}
+
+// FilterLogs filters contract logs for past blocks, returning the necessary
+// channels to construct a strongly typed bound iterator on top of them.
+func (c *BoundContract) FilterLogs(opts *FilterOpts, name string, query ...[]interface{}) (chan types.Log, event.Subscription, error) {
+ // Don't crash on a lazy user
+ if opts == nil {
+ opts = new(FilterOpts)
+ }
+ // Append the event selector to the query parameters and construct the topic set
+ query = append([][]interface{}{{c.abi.Events[name].ID}}, query...)
+
+ topics, err := abi.MakeTopics(query...)
+ if err != nil {
+ return nil, nil, err
+ }
+ // Start the background filtering
+ logs := make(chan types.Log, 128)
+
+ config := ethereum.FilterQuery{
+ Addresses: []common.Address{c.address},
+ Topics: topics,
+ FromBlock: new(big.Int).SetUint64(opts.Start),
+ }
+ if opts.End != nil {
+ config.ToBlock = new(big.Int).SetUint64(*opts.End)
+ }
+ /* TODO(karalabe): Replace the rest of the method below with this when supported
+ sub, err := c.filterer.SubscribeFilterLogs(ensureContext(opts.Context), config, logs)
+ */
+ buff, err := c.filterer.FilterLogs(ensureContext(opts.Context), config)
+ if err != nil {
+ return nil, nil, err
+ }
+ sub, err := event.NewSubscription(func(quit <-chan struct{}) error {
+ for _, log := range buff {
+ select {
+ case logs <- log:
+ case <-quit:
+ return nil
+ }
+ }
+ return nil
+ }), nil
+
+ if err != nil {
+ return nil, nil, err
+ }
+ return logs, sub, nil
+}
+
+// WatchLogs filters subscribes to contract logs for future blocks, returning a
+// subscription object that can be used to tear down the watcher.
+func (c *BoundContract) WatchLogs(opts *WatchOpts, name string, query ...[]interface{}) (chan types.Log, event.Subscription, error) {
+ // Don't crash on a lazy user
+ if opts == nil {
+ opts = new(WatchOpts)
+ }
+ // Append the event selector to the query parameters and construct the topic set
+ query = append([][]interface{}{{c.abi.Events[name].ID}}, query...)
+
+ topics, err := abi.MakeTopics(query...)
+ if err != nil {
+ return nil, nil, err
+ }
+ // Start the background filtering
+ logs := make(chan types.Log, 128)
+
+ config := ethereum.FilterQuery{
+ Addresses: []common.Address{c.address},
+ Topics: topics,
+ }
+ if opts.Start != nil {
+ config.FromBlock = new(big.Int).SetUint64(*opts.Start)
+ }
+ sub, err := c.filterer.SubscribeFilterLogs(ensureContext(opts.Context), config, logs)
+ if err != nil {
+ return nil, nil, err
+ }
+ return logs, sub, nil
+}
+
+// UnpackLog unpacks a retrieved log into the provided output structure.
+func (c *BoundContract) UnpackLog(out interface{}, event string, log types.Log) error {
+ if log.Topics[0] != c.abi.Events[event].ID {
+ return fmt.Errorf("event signature mismatch")
+ }
+ if len(log.Data) > 0 {
+ if err := c.abi.UnpackIntoInterface(out, event, log.Data); err != nil {
+ return err
+ }
+ }
+ var indexed abi.Arguments
+ for _, arg := range c.abi.Events[event].Inputs {
+ if arg.Indexed {
+ indexed = append(indexed, arg)
+ }
+ }
+ return abi.ParseTopics(out, indexed, log.Topics[1:])
+}
+
+// UnpackLogIntoMap unpacks a retrieved log into the provided map.
+func (c *BoundContract) UnpackLogIntoMap(out map[string]interface{}, event string, log types.Log) error {
+ if log.Topics[0] != c.abi.Events[event].ID {
+ return fmt.Errorf("event signature mismatch")
+ }
+ if len(log.Data) > 0 {
+ if err := c.abi.UnpackIntoMap(out, event, log.Data); err != nil {
+ return err
+ }
+ }
+ var indexed abi.Arguments
+ for _, arg := range c.abi.Events[event].Inputs {
+ if arg.Indexed {
+ indexed = append(indexed, arg)
+ }
+ }
+ return abi.ParseTopicsIntoMap(out, indexed, log.Topics[1:])
+}
+
+// ensureContext is a helper method to ensure a context is not nil, even if the
+// user specified it as such.
+func ensureContext(ctx context.Context) context.Context {
+ if ctx == nil {
+ return context.Background()
+ }
+ return ctx
+}
diff --git a/abigen/accounts/abi/bind/base_test.go b/abigen/accounts/abi/bind/base_test.go
new file mode 100644
index 00000000..25b2f8a8
--- /dev/null
+++ b/abigen/accounts/abi/bind/base_test.go
@@ -0,0 +1,498 @@
+// Copyright 2019 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package bind_test
+
+import (
+ "context"
+ "errors"
+ "math/big"
+ "reflect"
+ "strings"
+ "testing"
+
+ "github.com/ethereum/go-ethereum"
+ "github.com/ethereum/go-ethereum/accounts/abi"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/crypto"
+ "github.com/ethereum/go-ethereum/rlp"
+ "github.com/stretchr/testify/assert"
+)
+
+func mockSign(addr common.Address, tx *types.Transaction) (*types.Transaction, error) { return tx, nil }
+
+type mockTransactor struct {
+ baseFee *big.Int
+ gasTipCap *big.Int
+ gasPrice *big.Int
+ suggestGasTipCapCalled bool
+ suggestGasPriceCalled bool
+}
+
+func (mt *mockTransactor) HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) {
+ return &types.Header{BaseFee: mt.baseFee}, nil
+}
+
+func (mt *mockTransactor) PendingCodeAt(ctx context.Context, account common.Address) ([]byte, error) {
+ return []byte{1}, nil
+}
+
+func (mt *mockTransactor) PendingNonceAt(ctx context.Context, account common.Address) (uint64, error) {
+ return 0, nil
+}
+
+func (mt *mockTransactor) SuggestGasPrice(ctx context.Context) (*big.Int, error) {
+ mt.suggestGasPriceCalled = true
+ return mt.gasPrice, nil
+}
+
+func (mt *mockTransactor) SuggestGasTipCap(ctx context.Context) (*big.Int, error) {
+ mt.suggestGasTipCapCalled = true
+ return mt.gasTipCap, nil
+}
+
+func (mt *mockTransactor) EstimateGas(ctx context.Context, call ethereum.CallMsg) (gas uint64, err error) {
+ return 0, nil
+}
+
+func (mt *mockTransactor) SendTransaction(ctx context.Context, tx *types.Transaction) error {
+ return nil
+}
+
+type mockCaller struct {
+ codeAtBlockNumber *big.Int
+ callContractBlockNumber *big.Int
+ callContractBytes []byte
+ callContractErr error
+ codeAtBytes []byte
+ codeAtErr error
+}
+
+func (mc *mockCaller) CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error) {
+ mc.codeAtBlockNumber = blockNumber
+ return mc.codeAtBytes, mc.codeAtErr
+}
+
+func (mc *mockCaller) CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error) {
+ mc.callContractBlockNumber = blockNumber
+ return mc.callContractBytes, mc.callContractErr
+}
+
+type mockPendingCaller struct {
+ *mockCaller
+ pendingCodeAtBytes []byte
+ pendingCodeAtErr error
+ pendingCodeAtCalled bool
+ pendingCallContractCalled bool
+ pendingCallContractBytes []byte
+ pendingCallContractErr error
+}
+
+func (mc *mockPendingCaller) PendingCodeAt(ctx context.Context, contract common.Address) ([]byte, error) {
+ mc.pendingCodeAtCalled = true
+ return mc.pendingCodeAtBytes, mc.pendingCodeAtErr
+}
+
+func (mc *mockPendingCaller) PendingCallContract(ctx context.Context, call ethereum.CallMsg) ([]byte, error) {
+ mc.pendingCallContractCalled = true
+ return mc.pendingCallContractBytes, mc.pendingCallContractErr
+}
+
+func TestPassingBlockNumber(t *testing.T) {
+
+ mc := &mockPendingCaller{
+ mockCaller: &mockCaller{
+ codeAtBytes: []byte{1, 2, 3},
+ },
+ }
+
+ bc := bind.NewBoundContract(common.HexToAddress("0x0"), abi.ABI{
+ Methods: map[string]abi.Method{
+ "something": {
+ Name: "something",
+ Outputs: abi.Arguments{},
+ },
+ },
+ }, mc, nil, nil)
+
+ blockNumber := big.NewInt(42)
+
+ bc.Call(&bind.CallOpts{BlockNumber: blockNumber}, nil, "something")
+
+ if mc.callContractBlockNumber != blockNumber {
+ t.Fatalf("CallContract() was not passed the block number")
+ }
+
+ if mc.codeAtBlockNumber != blockNumber {
+ t.Fatalf("CodeAt() was not passed the block number")
+ }
+
+ bc.Call(&bind.CallOpts{}, nil, "something")
+
+ if mc.callContractBlockNumber != nil {
+ t.Fatalf("CallContract() was passed a block number when it should not have been")
+ }
+
+ if mc.codeAtBlockNumber != nil {
+ t.Fatalf("CodeAt() was passed a block number when it should not have been")
+ }
+
+ bc.Call(&bind.CallOpts{BlockNumber: blockNumber, Pending: true}, nil, "something")
+
+ if !mc.pendingCallContractCalled {
+ t.Fatalf("CallContract() was not passed the block number")
+ }
+
+ if !mc.pendingCodeAtCalled {
+ t.Fatalf("CodeAt() was not passed the block number")
+ }
+}
+
+const hexData = "0x000000000000000000000000376c47978271565f56deb45495afa69e59c16ab200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158"
+
+func TestUnpackIndexedStringTyLogIntoMap(t *testing.T) {
+ hash := crypto.Keccak256Hash([]byte("testName"))
+ topics := []common.Hash{
+ crypto.Keccak256Hash([]byte("received(string,address,uint256,bytes)")),
+ hash,
+ }
+ mockLog := newMockLog(topics, common.HexToHash("0x0"))
+
+ abiString := `[{"anonymous":false,"inputs":[{"indexed":true,"name":"name","type":"string"},{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"}]`
+ parsedAbi, _ := abi.JSON(strings.NewReader(abiString))
+ bc := bind.NewBoundContract(common.HexToAddress("0x0"), parsedAbi, nil, nil, nil)
+
+ expectedReceivedMap := map[string]interface{}{
+ "name": hash,
+ "sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"),
+ "amount": big.NewInt(1),
+ "memo": []byte{88},
+ }
+ unpackAndCheck(t, bc, expectedReceivedMap, mockLog)
+}
+
+func TestUnpackIndexedSliceTyLogIntoMap(t *testing.T) {
+ sliceBytes, err := rlp.EncodeToBytes([]string{"name1", "name2", "name3", "name4"})
+ if err != nil {
+ t.Fatal(err)
+ }
+ hash := crypto.Keccak256Hash(sliceBytes)
+ topics := []common.Hash{
+ crypto.Keccak256Hash([]byte("received(string[],address,uint256,bytes)")),
+ hash,
+ }
+ mockLog := newMockLog(topics, common.HexToHash("0x0"))
+
+ abiString := `[{"anonymous":false,"inputs":[{"indexed":true,"name":"names","type":"string[]"},{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"}]`
+ parsedAbi, _ := abi.JSON(strings.NewReader(abiString))
+ bc := bind.NewBoundContract(common.HexToAddress("0x0"), parsedAbi, nil, nil, nil)
+
+ expectedReceivedMap := map[string]interface{}{
+ "names": hash,
+ "sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"),
+ "amount": big.NewInt(1),
+ "memo": []byte{88},
+ }
+ unpackAndCheck(t, bc, expectedReceivedMap, mockLog)
+}
+
+func TestUnpackIndexedArrayTyLogIntoMap(t *testing.T) {
+ arrBytes, err := rlp.EncodeToBytes([2]common.Address{common.HexToAddress("0x0"), common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2")})
+ if err != nil {
+ t.Fatal(err)
+ }
+ hash := crypto.Keccak256Hash(arrBytes)
+ topics := []common.Hash{
+ crypto.Keccak256Hash([]byte("received(address[2],address,uint256,bytes)")),
+ hash,
+ }
+ mockLog := newMockLog(topics, common.HexToHash("0x0"))
+
+ abiString := `[{"anonymous":false,"inputs":[{"indexed":true,"name":"addresses","type":"address[2]"},{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"}]`
+ parsedAbi, _ := abi.JSON(strings.NewReader(abiString))
+ bc := bind.NewBoundContract(common.HexToAddress("0x0"), parsedAbi, nil, nil, nil)
+
+ expectedReceivedMap := map[string]interface{}{
+ "addresses": hash,
+ "sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"),
+ "amount": big.NewInt(1),
+ "memo": []byte{88},
+ }
+ unpackAndCheck(t, bc, expectedReceivedMap, mockLog)
+}
+
+func TestUnpackIndexedFuncTyLogIntoMap(t *testing.T) {
+ mockAddress := common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2")
+ addrBytes := mockAddress.Bytes()
+ hash := crypto.Keccak256Hash([]byte("mockFunction(address,uint)"))
+ functionSelector := hash[:4]
+ functionTyBytes := append(addrBytes, functionSelector...)
+ var functionTy [24]byte
+ copy(functionTy[:], functionTyBytes[0:24])
+ topics := []common.Hash{
+ crypto.Keccak256Hash([]byte("received(function,address,uint256,bytes)")),
+ common.BytesToHash(functionTyBytes),
+ }
+ mockLog := newMockLog(topics, common.HexToHash("0x5c698f13940a2153440c6d19660878bc90219d9298fdcf37365aa8d88d40fc42"))
+ abiString := `[{"anonymous":false,"inputs":[{"indexed":true,"name":"function","type":"function"},{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"}]`
+ parsedAbi, _ := abi.JSON(strings.NewReader(abiString))
+ bc := bind.NewBoundContract(common.HexToAddress("0x0"), parsedAbi, nil, nil, nil)
+
+ expectedReceivedMap := map[string]interface{}{
+ "function": functionTy,
+ "sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"),
+ "amount": big.NewInt(1),
+ "memo": []byte{88},
+ }
+ unpackAndCheck(t, bc, expectedReceivedMap, mockLog)
+}
+
+func TestUnpackIndexedBytesTyLogIntoMap(t *testing.T) {
+ bytes := []byte{1, 2, 3, 4, 5}
+ hash := crypto.Keccak256Hash(bytes)
+ topics := []common.Hash{
+ crypto.Keccak256Hash([]byte("received(bytes,address,uint256,bytes)")),
+ hash,
+ }
+ mockLog := newMockLog(topics, common.HexToHash("0x5c698f13940a2153440c6d19660878bc90219d9298fdcf37365aa8d88d40fc42"))
+
+ abiString := `[{"anonymous":false,"inputs":[{"indexed":true,"name":"content","type":"bytes"},{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"}]`
+ parsedAbi, _ := abi.JSON(strings.NewReader(abiString))
+ bc := bind.NewBoundContract(common.HexToAddress("0x0"), parsedAbi, nil, nil, nil)
+
+ expectedReceivedMap := map[string]interface{}{
+ "content": hash,
+ "sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"),
+ "amount": big.NewInt(1),
+ "memo": []byte{88},
+ }
+ unpackAndCheck(t, bc, expectedReceivedMap, mockLog)
+}
+
+func TestTransactGasFee(t *testing.T) {
+ assert := assert.New(t)
+
+ // GasTipCap and GasFeeCap
+ // When opts.GasTipCap and opts.GasFeeCap are nil
+ mt := &mockTransactor{baseFee: big.NewInt(100), gasTipCap: big.NewInt(5)}
+ bc := bind.NewBoundContract(common.Address{}, abi.ABI{}, nil, mt, nil)
+ opts := &bind.TransactOpts{Signer: mockSign}
+ tx, err := bc.Transact(opts, "")
+ assert.Nil(err)
+ assert.Equal(big.NewInt(5), tx.GasTipCap())
+ assert.Equal(big.NewInt(205), tx.GasFeeCap())
+ assert.Nil(opts.GasTipCap)
+ assert.Nil(opts.GasFeeCap)
+ assert.True(mt.suggestGasTipCapCalled)
+
+ // Second call to Transact should use latest suggested GasTipCap
+ mt.gasTipCap = big.NewInt(6)
+ mt.suggestGasTipCapCalled = false
+ tx, err = bc.Transact(opts, "")
+ assert.Nil(err)
+ assert.Equal(big.NewInt(6), tx.GasTipCap())
+ assert.Equal(big.NewInt(206), tx.GasFeeCap())
+ assert.True(mt.suggestGasTipCapCalled)
+
+ // GasPrice
+ // When opts.GasPrice is nil
+ mt = &mockTransactor{gasPrice: big.NewInt(5)}
+ bc = bind.NewBoundContract(common.Address{}, abi.ABI{}, nil, mt, nil)
+ opts = &bind.TransactOpts{Signer: mockSign}
+ tx, err = bc.Transact(opts, "")
+ assert.Nil(err)
+ assert.Equal(big.NewInt(5), tx.GasPrice())
+ assert.Nil(opts.GasPrice)
+ assert.True(mt.suggestGasPriceCalled)
+
+ // Second call to Transact should use latest suggested GasPrice
+ mt.gasPrice = big.NewInt(6)
+ mt.suggestGasPriceCalled = false
+ tx, err = bc.Transact(opts, "")
+ assert.Nil(err)
+ assert.Equal(big.NewInt(6), tx.GasPrice())
+ assert.True(mt.suggestGasPriceCalled)
+}
+
+func unpackAndCheck(t *testing.T, bc *bind.BoundContract, expected map[string]interface{}, mockLog types.Log) {
+ received := make(map[string]interface{})
+ if err := bc.UnpackLogIntoMap(received, "received", mockLog); err != nil {
+ t.Error(err)
+ }
+
+ if len(received) != len(expected) {
+ t.Fatalf("unpacked map length %v not equal expected length of %v", len(received), len(expected))
+ }
+ for name, elem := range expected {
+ if !reflect.DeepEqual(elem, received[name]) {
+ t.Errorf("field %v does not match expected, want %v, got %v", name, elem, received[name])
+ }
+ }
+}
+
+func newMockLog(topics []common.Hash, txHash common.Hash) types.Log {
+ return types.Log{
+ Address: common.HexToAddress("0x0"),
+ Topics: topics,
+ Data: hexutil.MustDecode(hexData),
+ BlockNumber: uint64(26),
+ TxHash: txHash,
+ TxIndex: 111,
+ BlockHash: common.BytesToHash([]byte{1, 2, 3, 4, 5}),
+ Index: 7,
+ Removed: false,
+ }
+}
+
+func TestCall(t *testing.T) {
+ var method, methodWithArg = "something", "somethingArrrrg"
+ tests := []struct {
+ name, method string
+ opts *bind.CallOpts
+ mc bind.ContractCaller
+ results *[]interface{}
+ wantErr bool
+ wantErrExact error
+ }{{
+ name: "ok not pending",
+ mc: &mockCaller{
+ codeAtBytes: []byte{0},
+ },
+ method: method,
+ }, {
+ name: "ok pending",
+ mc: &mockPendingCaller{
+ pendingCodeAtBytes: []byte{0},
+ },
+ opts: &bind.CallOpts{
+ Pending: true,
+ },
+ method: method,
+ }, {
+ name: "pack error, no method",
+ mc: new(mockCaller),
+ method: "else",
+ wantErr: true,
+ }, {
+ name: "interface error, pending but not a PendingContractCaller",
+ mc: new(mockCaller),
+ opts: &bind.CallOpts{
+ Pending: true,
+ },
+ method: method,
+ wantErrExact: bind.ErrNoPendingState,
+ }, {
+ name: "pending call canceled",
+ mc: &mockPendingCaller{
+ pendingCallContractErr: context.DeadlineExceeded,
+ },
+ opts: &bind.CallOpts{
+ Pending: true,
+ },
+ method: method,
+ wantErrExact: context.DeadlineExceeded,
+ }, {
+ name: "pending code at error",
+ mc: &mockPendingCaller{
+ pendingCodeAtErr: errors.New(""),
+ },
+ opts: &bind.CallOpts{
+ Pending: true,
+ },
+ method: method,
+ wantErr: true,
+ }, {
+ name: "no pending code at",
+ mc: new(mockPendingCaller),
+ opts: &bind.CallOpts{
+ Pending: true,
+ },
+ method: method,
+ wantErrExact: bind.ErrNoCode,
+ }, {
+ name: "call contract error",
+ mc: &mockCaller{
+ callContractErr: context.DeadlineExceeded,
+ },
+ method: method,
+ wantErrExact: context.DeadlineExceeded,
+ }, {
+ name: "code at error",
+ mc: &mockCaller{
+ codeAtErr: errors.New(""),
+ },
+ method: method,
+ wantErr: true,
+ }, {
+ name: "no code at",
+ mc: new(mockCaller),
+ method: method,
+ wantErrExact: bind.ErrNoCode,
+ }, {
+ name: "unpack error missing arg",
+ mc: &mockCaller{
+ codeAtBytes: []byte{0},
+ },
+ method: methodWithArg,
+ wantErr: true,
+ }, {
+ name: "interface unpack error",
+ mc: &mockCaller{
+ codeAtBytes: []byte{0},
+ },
+ method: method,
+ results: &[]interface{}{0},
+ wantErr: true,
+ }}
+ for _, test := range tests {
+ bc := bind.NewBoundContract(common.HexToAddress("0x0"), abi.ABI{
+ Methods: map[string]abi.Method{
+ method: {
+ Name: method,
+ Outputs: abi.Arguments{},
+ },
+ methodWithArg: {
+ Name: methodWithArg,
+ Outputs: abi.Arguments{abi.Argument{}},
+ },
+ },
+ }, test.mc, nil, nil)
+ err := bc.Call(test.opts, test.results, test.method)
+ if test.wantErr || test.wantErrExact != nil {
+ if err == nil {
+ t.Fatalf("%q expected error", test.name)
+ }
+ if test.wantErrExact != nil && !errors.Is(err, test.wantErrExact) {
+ t.Fatalf("%q expected error %q but got %q", test.name, test.wantErrExact, err)
+ }
+ continue
+ }
+ if err != nil {
+ t.Fatalf("%q unexpected error: %v", test.name, err)
+ }
+ }
+}
+
+// TestCrashers contains some strings which previously caused the abi codec to crash.
+func TestCrashers(t *testing.T) {
+ abi.JSON(strings.NewReader(`[{"inputs":[{"type":"tuple[]","components":[{"type":"bool","name":"_1"}]}]}]`))
+ abi.JSON(strings.NewReader(`[{"inputs":[{"type":"tuple[]","components":[{"type":"bool","name":"&"}]}]}]`))
+ abi.JSON(strings.NewReader(`[{"inputs":[{"type":"tuple[]","components":[{"type":"bool","name":"----"}]}]}]`))
+ abi.JSON(strings.NewReader(`[{"inputs":[{"type":"tuple[]","components":[{"type":"bool","name":"foo.Bar"}]}]}]`))
+}
diff --git a/abigen/accounts/abi/bind/bind.go b/abigen/accounts/abi/bind/bind.go
new file mode 100644
index 00000000..464f2c99
--- /dev/null
+++ b/abigen/accounts/abi/bind/bind.go
@@ -0,0 +1,618 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+// Package bind generates Ethereum contract Go bindings.
+//
+// Detailed usage document and tutorial available on the go-ethereum Wiki page:
+// https://github.com/ethereum/go-ethereum/wiki/Native-DApps:-Go-bindings-to-Ethereum-contracts
+package bind
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "go/format"
+ "regexp"
+ "strings"
+ "text/template"
+ "unicode"
+
+ "github.com/ethereum/go-ethereum/log"
+ "gitlab.com/alphaticks/abigen-starknet/accounts/abi"
+)
+
+// Lang is a target programming language selector to generate bindings for.
+type Lang int
+
+const (
+ LangGo Lang = iota
+ LangJava
+ LangObjC
+)
+
+// Bind generates a Go wrapper around a contract ABI. This wrapper isn't meant
+// to be used as is in client code, but rather as an intermediate struct which
+// enforces compile time type safety and naming convention opposed to having to
+// manually maintain hard coded strings that break on runtime.
+func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]string, pkg string, lang Lang, libs map[string]string, aliases map[string]string) (string, error) {
+ var (
+ // contracts is the map of each individual contract requested binding
+ contracts = make(map[string]*tmplContract)
+
+ // structs is the map of all redeclared structs shared by passed contracts.
+ structs = make(map[string]*tmplStruct)
+
+ // isLib is the map used to flag each encountered library as such
+ isLib = make(map[string]struct{})
+ )
+ for i := 0; i < len(types); i++ {
+ // Parse the actual ABI to generate the binding for
+ evmABI, err := abi.JSON(strings.NewReader(abis[i]))
+ if err != nil {
+ return "", err
+ }
+ // Strip any whitespace from the JSON ABI
+ strippedABI := strings.Map(func(r rune) rune {
+ if unicode.IsSpace(r) {
+ return -1
+ }
+ return r
+ }, abis[i])
+
+ // Extract the call and transact methods; events, struct definitions; and sort them alphabetically
+ var (
+ calls = make(map[string]*tmplMethod)
+ transacts = make(map[string]*tmplMethod)
+ events = make(map[string]*tmplEvent)
+ fallback *tmplMethod
+ receive *tmplMethod
+
+ // identifiers are used to detect duplicated identifiers of functions
+ // and events. For all calls, transacts and events, abigen will generate
+ // corresponding bindings. However we have to ensure there is no
+ // identifier collisions in the bindings of these categories.
+ callIdentifiers = make(map[string]bool)
+ transactIdentifiers = make(map[string]bool)
+ eventIdentifiers = make(map[string]bool)
+ )
+
+ for _, input := range evmABI.Constructor.Inputs {
+ if hasStruct(input.Type) {
+ bindStructType[lang](input.Type, structs)
+ }
+ }
+
+ for _, original := range evmABI.Methods {
+ // Normalize the method for capital cases and non-anonymous inputs/outputs
+ normalized := original
+ normalizedName := methodNormalizer[lang](alias(aliases, original.Name))
+
+ // Ensure there is no duplicated identifier
+ var identifiers = callIdentifiers
+ if !original.IsConstant() {
+ identifiers = transactIdentifiers
+ }
+ if identifiers[normalizedName] {
+ return "", fmt.Errorf("duplicated identifier \"%s\"(normalized \"%s\"), use --alias for renaming", original.Name, normalizedName)
+ }
+ identifiers[normalizedName] = true
+
+ normalized.Name = normalizedName
+ normalized.Inputs = make([]abi.Argument, len(original.Inputs))
+ copy(normalized.Inputs, original.Inputs)
+ for j, input := range normalized.Inputs {
+ if input.Name == "" {
+ normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j)
+ }
+ if hasStruct(input.Type) {
+ bindStructType[lang](input.Type, structs)
+ }
+ }
+ normalized.Outputs = make([]abi.Argument, len(original.Outputs))
+ copy(normalized.Outputs, original.Outputs)
+ for j, output := range normalized.Outputs {
+ if output.Name != "" {
+ normalized.Outputs[j].Name = capitalise(output.Name)
+ }
+ if hasStruct(output.Type) {
+ bindStructType[lang](output.Type, structs)
+ }
+ }
+ // Append the methods to the call or transact lists
+ if original.IsConstant() {
+ calls[original.Name] = &tmplMethod{Original: original, Normalized: normalized, Structured: structured(original.Outputs)}
+ } else {
+ transacts[original.Name] = &tmplMethod{Original: original, Normalized: normalized, Structured: structured(original.Outputs)}
+ }
+ }
+ for _, original := range evmABI.Events {
+ // Skip anonymous events as they don't support explicit filtering
+ if original.Anonymous {
+ continue
+ }
+ // Normalize the event for capital cases and non-anonymous outputs
+ normalized := original
+
+ // Ensure there is no duplicated identifier
+ normalizedName := methodNormalizer[lang](alias(aliases, original.Name))
+ if eventIdentifiers[normalizedName] {
+ return "", fmt.Errorf("duplicated identifier \"%s\"(normalized \"%s\"), use --alias for renaming", original.Name, normalizedName)
+ }
+ eventIdentifiers[normalizedName] = true
+ normalized.Name = normalizedName
+
+ used := make(map[string]bool)
+ normalized.Inputs = make([]abi.Argument, len(original.Inputs))
+ copy(normalized.Inputs, original.Inputs)
+ for j, input := range normalized.Inputs {
+ if input.Name == "" {
+ normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j)
+ }
+ // Event is a bit special, we need to define event struct in binding,
+ // ensure there is no camel-case-style name conflict.
+ for index := 0; ; index++ {
+ if !used[capitalise(normalized.Inputs[j].Name)] {
+ used[capitalise(normalized.Inputs[j].Name)] = true
+ break
+ }
+ normalized.Inputs[j].Name = fmt.Sprintf("%s%d", normalized.Inputs[j].Name, index)
+ }
+ if hasStruct(input.Type) {
+ bindStructType[lang](input.Type, structs)
+ }
+ }
+ // Append the event to the accumulator list
+ events[original.Name] = &tmplEvent{Original: original, Normalized: normalized}
+ }
+ // Add two special fallback functions if they exist
+ if evmABI.HasFallback() {
+ fallback = &tmplMethod{Original: evmABI.Fallback}
+ }
+ if evmABI.HasReceive() {
+ receive = &tmplMethod{Original: evmABI.Receive}
+ }
+ // There is no easy way to pass arbitrary java objects to the Go side.
+ if len(structs) > 0 && lang == LangJava {
+ return "", errors.New("java binding for tuple arguments is not supported yet")
+ }
+
+ contracts[types[i]] = &tmplContract{
+ Type: capitalise(types[i]),
+ InputABI: strings.ReplaceAll(strippedABI, "\"", "\\\""),
+ InputBin: strings.TrimPrefix(strings.TrimSpace(bytecodes[i]), "0x"),
+ Constructor: evmABI.Constructor,
+ Calls: calls,
+ Transacts: transacts,
+ Fallback: fallback,
+ Receive: receive,
+ Events: events,
+ Libraries: make(map[string]string),
+ }
+ // Function 4-byte signatures are stored in the same sequence
+ // as types, if available.
+ if len(fsigs) > i {
+ contracts[types[i]].FuncSigs = fsigs[i]
+ }
+ // Parse library references.
+ for pattern, name := range libs {
+ matched, err := regexp.Match("__\\$"+pattern+"\\$__", []byte(contracts[types[i]].InputBin))
+ if err != nil {
+ log.Error("Could not search for pattern", "pattern", pattern, "contract", contracts[types[i]], "err", err)
+ }
+ if matched {
+ contracts[types[i]].Libraries[pattern] = name
+ // keep track that this type is a library
+ if _, ok := isLib[name]; !ok {
+ isLib[name] = struct{}{}
+ }
+ }
+ }
+ }
+ // Check if that type has already been identified as a library
+ for i := 0; i < len(types); i++ {
+ _, ok := isLib[types[i]]
+ contracts[types[i]].Library = ok
+ }
+ // Generate the contract template data content and render it
+ data := &tmplData{
+ Package: pkg,
+ Contracts: contracts,
+ Libraries: libs,
+ Structs: structs,
+ }
+ buffer := new(bytes.Buffer)
+
+ funcs := map[string]interface{}{
+ "bindtype": bindType[lang],
+ "bindtopictype": bindTopicType[lang],
+ "namedtype": namedType[lang],
+ "capitalise": capitalise,
+ "decapitalise": decapitalise,
+ }
+ tmpl := template.Must(template.New("").Funcs(funcs).Parse(tmplSource[lang]))
+ if err := tmpl.Execute(buffer, data); err != nil {
+ return "", err
+ }
+ // For Go bindings pass the code through gofmt to clean it up
+ if lang == LangGo {
+ code, err := format.Source(buffer.Bytes())
+ if err != nil {
+ return "", fmt.Errorf("%v\n%s", err, buffer)
+ }
+ cod := string(code)
+ ex, err := regexp.Compile(`github.com/ethereum/go-ethereum/accounts`)
+ if err != nil {
+ return "", fmt.Errorf("cannot parse regexp: %v", err)
+ }
+ cod = ex.ReplaceAllString(cod, "gitlab.com/alphaticks/abigen-starknet/accounts")
+ return cod, nil
+ }
+ // For all others just return as is for now
+ return buffer.String(), nil
+}
+
+// bindType is a set of type binders that convert Solidity types to some supported
+// programming language types.
+var bindType = map[Lang]func(kind abi.Type, structs map[string]*tmplStruct) string{
+ LangGo: bindTypeGo,
+ LangJava: bindTypeJava,
+}
+
+// bindBasicTypeGo converts basic solidity types(except array, slice and tuple) to Go ones.
+func bindBasicTypeGo(kind abi.Type) string {
+ switch kind.T {
+ case abi.AddressTy:
+ return "common.Address"
+ case abi.IntTy, abi.UintTy:
+ parts := regexp.MustCompile(`(u)?int([0-9]*)`).FindStringSubmatch(kind.String())
+ switch parts[2] {
+ case "8", "16", "32", "64":
+ return fmt.Sprintf("%sint%s", parts[1], parts[2])
+ }
+ return "*big.Int"
+ case abi.FixedBytesTy:
+ return fmt.Sprintf("[%d]byte", kind.Size)
+ case abi.BytesTy:
+ return "[]byte"
+ case abi.FunctionTy:
+ return "[24]byte"
+ default:
+ // string, bool types
+ return kind.String()
+ }
+}
+
+// bindTypeGo converts solidity types to Go ones. Since there is no clear mapping
+// from all Solidity types to Go ones (e.g. uint17), those that cannot be exactly
+// mapped will use an upscaled type (e.g. BigDecimal).
+func bindTypeGo(kind abi.Type, structs map[string]*tmplStruct) string {
+ switch kind.T {
+ case abi.TupleTy:
+ return structs[kind.TupleRawName+kind.String()].Name
+ case abi.ArrayTy:
+ return fmt.Sprintf("[%d]", kind.Size) + bindTypeGo(*kind.Elem, structs)
+ case abi.SliceTy:
+ return "[]" + bindTypeGo(*kind.Elem, structs)
+ default:
+ return bindBasicTypeGo(kind)
+ }
+}
+
+// bindBasicTypeJava converts basic solidity types(except array, slice and tuple) to Java ones.
+func bindBasicTypeJava(kind abi.Type) string {
+ switch kind.T {
+ case abi.AddressTy:
+ return "Address"
+ case abi.IntTy, abi.UintTy:
+ // Note that uint and int (without digits) are also matched,
+ // these are size 256, and will translate to BigInt (the default).
+ parts := regexp.MustCompile(`(u)?int([0-9]*)`).FindStringSubmatch(kind.String())
+ if len(parts) != 3 {
+ return kind.String()
+ }
+ // All unsigned integers should be translated to BigInt since gomobile doesn't
+ // support them.
+ if parts[1] == "u" {
+ return "BigInt"
+ }
+
+ namedSize := map[string]string{
+ "8": "byte",
+ "16": "short",
+ "32": "int",
+ "64": "long",
+ }[parts[2]]
+
+ // default to BigInt
+ if namedSize == "" {
+ namedSize = "BigInt"
+ }
+ return namedSize
+ case abi.FixedBytesTy, abi.BytesTy:
+ return "byte[]"
+ case abi.BoolTy:
+ return "boolean"
+ case abi.StringTy:
+ return "String"
+ case abi.FunctionTy:
+ return "byte[24]"
+ default:
+ return kind.String()
+ }
+}
+
+// pluralizeJavaType explicitly converts multidimensional types to predefined
+// types in go side.
+func pluralizeJavaType(typ string) string {
+ switch typ {
+ case "boolean":
+ return "Bools"
+ case "String":
+ return "Strings"
+ case "Address":
+ return "Addresses"
+ case "byte[]":
+ return "Binaries"
+ case "BigInt":
+ return "BigInts"
+ }
+ return typ + "[]"
+}
+
+// bindTypeJava converts a Solidity type to a Java one. Since there is no clear mapping
+// from all Solidity types to Java ones (e.g. uint17), those that cannot be exactly
+// mapped will use an upscaled type (e.g. BigDecimal).
+func bindTypeJava(kind abi.Type, structs map[string]*tmplStruct) string {
+ switch kind.T {
+ case abi.TupleTy:
+ return structs[kind.TupleRawName+kind.String()].Name
+ case abi.ArrayTy, abi.SliceTy:
+ return pluralizeJavaType(bindTypeJava(*kind.Elem, structs))
+ default:
+ return bindBasicTypeJava(kind)
+ }
+}
+
+// bindTopicType is a set of type binders that convert Solidity types to some
+// supported programming language topic types.
+var bindTopicType = map[Lang]func(kind abi.Type, structs map[string]*tmplStruct) string{
+ LangGo: bindTopicTypeGo,
+ LangJava: bindTopicTypeJava,
+}
+
+// bindTopicTypeGo converts a Solidity topic type to a Go one. It is almost the same
+// functionality as for simple types, but dynamic types get converted to hashes.
+func bindTopicTypeGo(kind abi.Type, structs map[string]*tmplStruct) string {
+ bound := bindTypeGo(kind, structs)
+
+ // todo(rjl493456442) according solidity documentation, indexed event
+ // parameters that are not value types i.e. arrays and structs are not
+ // stored directly but instead a keccak256-hash of an encoding is stored.
+ //
+ // We only convert stringS and bytes to hash, still need to deal with
+ // array(both fixed-size and dynamic-size) and struct.
+ if bound == "string" || bound == "[]byte" {
+ bound = "common.Hash"
+ }
+ return bound
+}
+
+// bindTopicTypeJava converts a Solidity topic type to a Java one. It is almost the same
+// functionality as for simple types, but dynamic types get converted to hashes.
+func bindTopicTypeJava(kind abi.Type, structs map[string]*tmplStruct) string {
+ bound := bindTypeJava(kind, structs)
+
+ // todo(rjl493456442) according solidity documentation, indexed event
+ // parameters that are not value types i.e. arrays and structs are not
+ // stored directly but instead a keccak256-hash of an encoding is stored.
+ //
+ // We only convert strings and bytes to hash, still need to deal with
+ // array(both fixed-size and dynamic-size) and struct.
+ if bound == "String" || bound == "byte[]" {
+ bound = "Hash"
+ }
+ return bound
+}
+
+// bindStructType is a set of type binders that convert Solidity tuple types to some supported
+// programming language struct definition.
+var bindStructType = map[Lang]func(kind abi.Type, structs map[string]*tmplStruct) string{
+ LangGo: bindStructTypeGo,
+ LangJava: bindStructTypeJava,
+}
+
+// bindStructTypeGo converts a Solidity tuple type to a Go one and records the mapping
+// in the given map.
+// Notably, this function will resolve and record nested struct recursively.
+func bindStructTypeGo(kind abi.Type, structs map[string]*tmplStruct) string {
+ switch kind.T {
+ case abi.TupleTy:
+ // We compose a raw struct name and a canonical parameter expression
+ // together here. The reason is before solidity v0.5.11, kind.TupleRawName
+ // is empty, so we use canonical parameter expression to distinguish
+ // different struct definition. From the consideration of backward
+ // compatibility, we concat these two together so that if kind.TupleRawName
+ // is not empty, it can have unique id.
+ id := kind.TupleRawName + kind.String()
+ if s, exist := structs[id]; exist {
+ return s.Name
+ }
+ var (
+ names = make(map[string]bool)
+ fields []*tmplField
+ )
+ for i, elem := range kind.TupleElems {
+ name := capitalise(kind.TupleRawNames[i])
+ name = abi.ResolveNameConflict(name, func(s string) bool { return names[s] })
+ names[name] = true
+ fields = append(fields, &tmplField{Type: bindStructTypeGo(*elem, structs), Name: name, SolKind: *elem})
+ }
+ name := kind.TupleRawName
+ if name == "" {
+ name = fmt.Sprintf("Struct%d", len(structs))
+ }
+ name = capitalise(name)
+
+ structs[id] = &tmplStruct{
+ Name: name,
+ Fields: fields,
+ }
+ return name
+ case abi.ArrayTy:
+ return fmt.Sprintf("[%d]", kind.Size) + bindStructTypeGo(*kind.Elem, structs)
+ case abi.SliceTy:
+ return "[]" + bindStructTypeGo(*kind.Elem, structs)
+ default:
+ return bindBasicTypeGo(kind)
+ }
+}
+
+// bindStructTypeJava converts a Solidity tuple type to a Java one and records the mapping
+// in the given map.
+// Notably, this function will resolve and record nested struct recursively.
+func bindStructTypeJava(kind abi.Type, structs map[string]*tmplStruct) string {
+ switch kind.T {
+ case abi.TupleTy:
+ // We compose a raw struct name and a canonical parameter expression
+ // together here. The reason is before solidity v0.5.11, kind.TupleRawName
+ // is empty, so we use canonical parameter expression to distinguish
+ // different struct definition. From the consideration of backward
+ // compatibility, we concat these two together so that if kind.TupleRawName
+ // is not empty, it can have unique id.
+ id := kind.TupleRawName + kind.String()
+ if s, exist := structs[id]; exist {
+ return s.Name
+ }
+ var fields []*tmplField
+ for i, elem := range kind.TupleElems {
+ field := bindStructTypeJava(*elem, structs)
+ fields = append(fields, &tmplField{Type: field, Name: decapitalise(kind.TupleRawNames[i]), SolKind: *elem})
+ }
+ name := kind.TupleRawName
+ if name == "" {
+ name = fmt.Sprintf("Class%d", len(structs))
+ }
+ structs[id] = &tmplStruct{
+ Name: name,
+ Fields: fields,
+ }
+ return name
+ case abi.ArrayTy, abi.SliceTy:
+ return pluralizeJavaType(bindStructTypeJava(*kind.Elem, structs))
+ default:
+ return bindBasicTypeJava(kind)
+ }
+}
+
+// namedType is a set of functions that transform language specific types to
+// named versions that may be used inside method names.
+var namedType = map[Lang]func(string, abi.Type) string{
+ LangGo: func(string, abi.Type) string { panic("this shouldn't be needed") },
+ LangJava: namedTypeJava,
+}
+
+// namedTypeJava converts some primitive data types to named variants that can
+// be used as parts of method names.
+func namedTypeJava(javaKind string, solKind abi.Type) string {
+ switch javaKind {
+ case "byte[]":
+ return "Binary"
+ case "boolean":
+ return "Bool"
+ default:
+ parts := regexp.MustCompile(`(u)?int([0-9]*)(\[[0-9]*\])?`).FindStringSubmatch(solKind.String())
+ if len(parts) != 4 {
+ return javaKind
+ }
+ switch parts[2] {
+ case "8", "16", "32", "64":
+ if parts[3] == "" {
+ return capitalise(fmt.Sprintf("%sint%s", parts[1], parts[2]))
+ }
+ return capitalise(fmt.Sprintf("%sint%ss", parts[1], parts[2]))
+
+ default:
+ return javaKind
+ }
+ }
+}
+
+// alias returns an alias of the given string based on the aliasing rules
+// or returns itself if no rule is matched.
+func alias(aliases map[string]string, n string) string {
+ if alias, exist := aliases[n]; exist {
+ return alias
+ }
+ return n
+}
+
+// methodNormalizer is a name transformer that modifies Solidity method names to
+// conform to target language naming conventions.
+var methodNormalizer = map[Lang]func(string) string{
+ LangGo: abi.ToCamelCase,
+ LangJava: decapitalise,
+}
+
+// capitalise makes a camel-case string which starts with an upper case character.
+var capitalise = abi.ToCamelCase
+
+// decapitalise makes a camel-case string which starts with a lower case character.
+func decapitalise(input string) string {
+ if len(input) == 0 {
+ return input
+ }
+
+ goForm := abi.ToCamelCase(input)
+ return strings.ToLower(goForm[:1]) + goForm[1:]
+}
+
+// structured checks whether a list of ABI data types has enough information to
+// operate through a proper Go struct or if flat returns are needed.
+func structured(args abi.Arguments) bool {
+ if len(args) < 2 {
+ return false
+ }
+ exists := make(map[string]bool)
+ for _, out := range args {
+ // If the name is anonymous, we can't organize into a struct
+ if out.Name == "" {
+ return false
+ }
+ // If the field name is empty when normalized or collides (var, Var, _var, _Var),
+ // we can't organize into a struct
+ field := capitalise(out.Name)
+ if field == "" || exists[field] {
+ return false
+ }
+ exists[field] = true
+ }
+ return true
+}
+
+// hasStruct returns an indicator whether the given type is struct, struct slice
+// or struct array.
+func hasStruct(t abi.Type) bool {
+ switch t.T {
+ case abi.SliceTy:
+ return hasStruct(*t.Elem)
+ case abi.ArrayTy:
+ return hasStruct(*t.Elem)
+ case abi.TupleTy:
+ return true
+ default:
+ return false
+ }
+}
diff --git a/abigen/accounts/abi/bind/bind_test.go b/abigen/accounts/abi/bind/bind_test.go
new file mode 100644
index 00000000..b71d85ee
--- /dev/null
+++ b/abigen/accounts/abi/bind/bind_test.go
@@ -0,0 +1,2485 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package bind
+
+import (
+ "fmt"
+ "os"
+ "os/exec"
+ "path/filepath"
+ "runtime"
+ "strings"
+ "testing"
+
+ "github.com/ethereum/go-ethereum/common"
+)
+
+var bindTests = []struct {
+ name string
+ contract string
+ bytecode []string
+ abi []string
+ imports string
+ tester string
+ fsigs []map[string]string
+ libs map[string]string
+ aliases map[string]string
+ types []string
+}{
+ // Test that the binding is available in combined and separate forms too
+ {
+ `Empty`,
+ `contract NilContract {}`,
+ []string{`606060405260068060106000396000f3606060405200`},
+ []string{`[]`},
+ `"github.com/ethereum/go-ethereum/common"`,
+ `
+ if b, err := NewEmpty(common.Address{}, nil); b == nil || err != nil {
+ t.Fatalf("combined binding (%v) nil or error (%v) not nil", b, nil)
+ }
+ if b, err := NewEmptyCaller(common.Address{}, nil); b == nil || err != nil {
+ t.Fatalf("caller binding (%v) nil or error (%v) not nil", b, nil)
+ }
+ if b, err := NewEmptyTransactor(common.Address{}, nil); b == nil || err != nil {
+ t.Fatalf("transactor binding (%v) nil or error (%v) not nil", b, nil)
+ }
+ `,
+ nil,
+ nil,
+ nil,
+ nil,
+ },
+ // Test that all the official sample contracts bind correctly
+ {
+ `Token`,
+ `https://ethereum.org/token`,
+ []string{`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`},
+ []string{`[{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"type":"function"},{"constant":false,"inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transferFrom","outputs":[{"name":"success","type":"bool"}],"type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transfer","outputs":[],"type":"function"},{"constant":false,"inputs":[{"name":"_spender","type":"address"},{"name":"_value","type":"uint256"},{"name":"_extraData","type":"bytes"}],"name":"approveAndCall","outputs":[{"name":"success","type":"bool"}],"type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"},{"name":"","type":"address"}],"name":"spentAllowance","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"},{"name":"","type":"address"}],"name":"allowance","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"inputs":[{"name":"initialSupply","type":"uint256"},{"name":"tokenName","type":"string"},{"name":"decimalUnits","type":"uint8"},{"name":"tokenSymbol","type":"string"}],"type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"name":"from","type":"address"},{"indexed":true,"name":"to","type":"address"},{"indexed":false,"name":"value","type":"uint256"}],"name":"Transfer","type":"event"}]`},
+ `"github.com/ethereum/go-ethereum/common"`,
+ `
+ if b, err := NewToken(common.Address{}, nil); b == nil || err != nil {
+ t.Fatalf("binding (%v) nil or error (%v) not nil", b, nil)
+ }
+ `,
+ nil,
+ nil,
+ nil,
+ nil,
+ },
+ {
+ `Crowdsale`,
+ `https://ethereum.org/crowdsale`,
+ []string{`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`},
+ []string{`[{"constant":false,"inputs":[],"name":"checkGoalReached","outputs":[],"type":"function"},{"constant":true,"inputs":[],"name":"deadline","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"beneficiary","outputs":[{"name":"","type":"address"}],"type":"function"},{"constant":true,"inputs":[],"name":"tokenReward","outputs":[{"name":"","type":"address"}],"type":"function"},{"constant":true,"inputs":[],"name":"fundingGoal","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"amountRaised","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"price","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"funders","outputs":[{"name":"addr","type":"address"},{"name":"amount","type":"uint256"}],"type":"function"},{"inputs":[{"name":"ifSuccessfulSendTo","type":"address"},{"name":"fundingGoalInEthers","type":"uint256"},{"name":"durationInMinutes","type":"uint256"},{"name":"etherCostOfEachToken","type":"uint256"},{"name":"addressOfTokenUsedAsReward","type":"address"}],"type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"name":"backer","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"isContribution","type":"bool"}],"name":"FundTransfer","type":"event"}]`},
+ `"github.com/ethereum/go-ethereum/common"`,
+ `
+ if b, err := NewCrowdsale(common.Address{}, nil); b == nil || err != nil {
+ t.Fatalf("binding (%v) nil or error (%v) not nil", b, nil)
+ }
+ `,
+ nil,
+ nil,
+ nil,
+ nil,
+ },
+ {
+ `DAO`,
+ `https://ethereum.org/dao`,
+ []string{`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`},
+ []string{`[{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"proposals","outputs":[{"name":"recipient","type":"address"},{"name":"amount","type":"uint256"},{"name":"description","type":"string"},{"name":"votingDeadline","type":"uint256"},{"name":"executed","type":"bool"},{"name":"proposalPassed","type":"bool"},{"name":"numberOfVotes","type":"uint256"},{"name":"currentResult","type":"int256"},{"name":"proposalHash","type":"bytes32"}],"type":"function"},{"constant":false,"inputs":[{"name":"proposalNumber","type":"uint256"},{"name":"transactionBytecode","type":"bytes"}],"name":"executeProposal","outputs":[{"name":"result","type":"int256"}],"type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"memberId","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"numProposals","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"members","outputs":[{"name":"member","type":"address"},{"name":"canVote","type":"bool"},{"name":"name","type":"string"},{"name":"memberSince","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"debatingPeriodInMinutes","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"minimumQuorum","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"type":"function"},{"constant":false,"inputs":[{"name":"targetMember","type":"address"},{"name":"canVote","type":"bool"},{"name":"memberName","type":"string"}],"name":"changeMembership","outputs":[],"type":"function"},{"constant":true,"inputs":[],"name":"majorityMargin","outputs":[{"name":"","type":"int256"}],"type":"function"},{"constant":false,"inputs":[{"name":"beneficiary","type":"address"},{"name":"etherAmount","type":"uint256"},{"name":"JobDescription","type":"string"},{"name":"transactionBytecode","type":"bytes"}],"name":"newProposal","outputs":[{"name":"proposalID","type":"uint256"}],"type":"function"},{"constant":false,"inputs":[{"name":"minimumQuorumForProposals","type":"uint256"},{"name":"minutesForDebate","type":"uint256"},{"name":"marginOfVotesForMajority","type":"int256"}],"name":"changeVotingRules","outputs":[],"type":"function"},{"constant":false,"inputs":[{"name":"proposalNumber","type":"uint256"},{"name":"supportsProposal","type":"bool"},{"name":"justificationText","type":"string"}],"name":"vote","outputs":[{"name":"voteID","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[{"name":"proposalNumber","type":"uint256"},{"name":"beneficiary","type":"address"},{"name":"etherAmount","type":"uint256"},{"name":"transactionBytecode","type":"bytes"}],"name":"checkProposalCode","outputs":[{"name":"codeChecksOut","type":"bool"}],"type":"function"},{"constant":false,"inputs":[{"name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"type":"function"},{"inputs":[{"name":"minimumQuorumForProposals","type":"uint256"},{"name":"minutesForDebate","type":"uint256"},{"name":"marginOfVotesForMajority","type":"int256"},{"name":"congressLeader","type":"address"}],"type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"name":"proposalID","type":"uint256"},{"indexed":false,"name":"recipient","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"description","type":"string"}],"name":"ProposalAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"proposalID","type":"uint256"},{"indexed":false,"name":"position","type":"bool"},{"indexed":false,"name":"voter","type":"address"},{"indexed":false,"name":"justification","type":"string"}],"name":"Voted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"proposalID","type":"uint256"},{"indexed":false,"name":"result","type":"int256"},{"indexed":false,"name":"quorum","type":"uint256"},{"indexed":false,"name":"active","type":"bool"}],"name":"ProposalTallied","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"member","type":"address"},{"indexed":false,"name":"isMember","type":"bool"}],"name":"MembershipChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"minimumQuorum","type":"uint256"},{"indexed":false,"name":"debatingPeriodInMinutes","type":"uint256"},{"indexed":false,"name":"majorityMargin","type":"int256"}],"name":"ChangeOfRules","type":"event"}]`},
+ `"github.com/ethereum/go-ethereum/common"`,
+ `
+ if b, err := NewDAO(common.Address{}, nil); b == nil || err != nil {
+ t.Fatalf("binding (%v) nil or error (%v) not nil", b, nil)
+ }
+ `,
+ nil,
+ nil,
+ nil,
+ nil,
+ },
+ // Test that named and anonymous inputs are handled correctly
+ {
+ `InputChecker`, ``, []string{``},
+ []string{`
+ [
+ {"type":"function","name":"noInput","constant":true,"inputs":[],"outputs":[]},
+ {"type":"function","name":"namedInput","constant":true,"inputs":[{"name":"str","type":"string"}],"outputs":[]},
+ {"type":"function","name":"anonInput","constant":true,"inputs":[{"name":"","type":"string"}],"outputs":[]},
+ {"type":"function","name":"namedInputs","constant":true,"inputs":[{"name":"str1","type":"string"},{"name":"str2","type":"string"}],"outputs":[]},
+ {"type":"function","name":"anonInputs","constant":true,"inputs":[{"name":"","type":"string"},{"name":"","type":"string"}],"outputs":[]},
+ {"type":"function","name":"mixedInputs","constant":true,"inputs":[{"name":"","type":"string"},{"name":"str","type":"string"}],"outputs":[]}
+ ]
+ `},
+ `
+ "fmt"
+
+ "github.com/ethereum/go-ethereum/common"
+ `,
+ `if b, err := NewInputChecker(common.Address{}, nil); b == nil || err != nil {
+ t.Fatalf("binding (%v) nil or error (%v) not nil", b, nil)
+ } else if false { // Don't run, just compile and test types
+ var err error
+
+ err = b.NoInput(nil)
+ err = b.NamedInput(nil, "")
+ err = b.AnonInput(nil, "")
+ err = b.NamedInputs(nil, "", "")
+ err = b.AnonInputs(nil, "", "")
+ err = b.MixedInputs(nil, "", "")
+
+ fmt.Println(err)
+ }`,
+ nil,
+ nil,
+ nil,
+ nil,
+ },
+ // Test that named and anonymous outputs are handled correctly
+ {
+ `OutputChecker`, ``, []string{``},
+ []string{`
+ [
+ {"type":"function","name":"noOutput","constant":true,"inputs":[],"outputs":[]},
+ {"type":"function","name":"namedOutput","constant":true,"inputs":[],"outputs":[{"name":"str","type":"string"}]},
+ {"type":"function","name":"anonOutput","constant":true,"inputs":[],"outputs":[{"name":"","type":"string"}]},
+ {"type":"function","name":"namedOutputs","constant":true,"inputs":[],"outputs":[{"name":"str1","type":"string"},{"name":"str2","type":"string"}]},
+ {"type":"function","name":"collidingOutputs","constant":true,"inputs":[],"outputs":[{"name":"str","type":"string"},{"name":"Str","type":"string"}]},
+ {"type":"function","name":"anonOutputs","constant":true,"inputs":[],"outputs":[{"name":"","type":"string"},{"name":"","type":"string"}]},
+ {"type":"function","name":"mixedOutputs","constant":true,"inputs":[],"outputs":[{"name":"","type":"string"},{"name":"str","type":"string"}]}
+ ]
+ `},
+ `
+ "fmt"
+
+ "github.com/ethereum/go-ethereum/common"
+ `,
+ `if b, err := NewOutputChecker(common.Address{}, nil); b == nil || err != nil {
+ t.Fatalf("binding (%v) nil or error (%v) not nil", b, nil)
+ } else if false { // Don't run, just compile and test types
+ var str1, str2 string
+ var err error
+
+ err = b.NoOutput(nil)
+ str1, err = b.NamedOutput(nil)
+ str1, err = b.AnonOutput(nil)
+ res, _ := b.NamedOutputs(nil)
+ str1, str2, err = b.CollidingOutputs(nil)
+ str1, str2, err = b.AnonOutputs(nil)
+ str1, str2, err = b.MixedOutputs(nil)
+
+ fmt.Println(str1, str2, res.Str1, res.Str2, err)
+ }`,
+ nil,
+ nil,
+ nil,
+ nil,
+ },
+ // Tests that named, anonymous and indexed events are handled correctly
+ {
+ `EventChecker`, ``, []string{``},
+ []string{`
+ [
+ {"type":"event","name":"empty","inputs":[]},
+ {"type":"event","name":"indexed","inputs":[{"name":"addr","type":"address","indexed":true},{"name":"num","type":"int256","indexed":true}]},
+ {"type":"event","name":"mixed","inputs":[{"name":"addr","type":"address","indexed":true},{"name":"num","type":"int256"}]},
+ {"type":"event","name":"anonymous","anonymous":true,"inputs":[]},
+ {"type":"event","name":"dynamic","inputs":[{"name":"idxStr","type":"string","indexed":true},{"name":"idxDat","type":"bytes","indexed":true},{"name":"str","type":"string"},{"name":"dat","type":"bytes"}]},
+ {"type":"event","name":"unnamed","inputs":[{"name":"","type":"uint256","indexed": true},{"name":"","type":"uint256","indexed":true}]}
+ ]
+ `},
+ `
+ "fmt"
+ "math/big"
+ "reflect"
+
+ "github.com/ethereum/go-ethereum/common"
+ `,
+ `if e, err := NewEventChecker(common.Address{}, nil); e == nil || err != nil {
+ t.Fatalf("binding (%v) nil or error (%v) not nil", e, nil)
+ } else if false { // Don't run, just compile and test types
+ var (
+ err error
+ res bool
+ str string
+ dat []byte
+ hash common.Hash
+ )
+ _, err = e.FilterEmpty(nil)
+ _, err = e.FilterIndexed(nil, []common.Address{}, []*big.Int{})
+
+ mit, err := e.FilterMixed(nil, []common.Address{})
+
+ res = mit.Next() // Make sure the iterator has a Next method
+ err = mit.Error() // Make sure the iterator has an Error method
+ err = mit.Close() // Make sure the iterator has a Close method
+
+ fmt.Println(mit.Event.Raw.BlockHash) // Make sure the raw log is contained within the results
+ fmt.Println(mit.Event.Num) // Make sure the unpacked non-indexed fields are present
+ fmt.Println(mit.Event.Addr) // Make sure the reconstructed indexed fields are present
+
+ dit, err := e.FilterDynamic(nil, []string{}, [][]byte{})
+
+ str = dit.Event.Str // Make sure non-indexed strings retain their type
+ dat = dit.Event.Dat // Make sure non-indexed bytes retain their type
+ hash = dit.Event.IdxStr // Make sure indexed strings turn into hashes
+ hash = dit.Event.IdxDat // Make sure indexed bytes turn into hashes
+
+ sink := make(chan *EventCheckerMixed)
+ sub, err := e.WatchMixed(nil, sink, []common.Address{})
+ defer sub.Unsubscribe()
+
+ event := <-sink
+ fmt.Println(event.Raw.BlockHash) // Make sure the raw log is contained within the results
+ fmt.Println(event.Num) // Make sure the unpacked non-indexed fields are present
+ fmt.Println(event.Addr) // Make sure the reconstructed indexed fields are present
+
+ fmt.Println(res, str, dat, hash, err)
+
+ oit, err := e.FilterUnnamed(nil, []*big.Int{}, []*big.Int{})
+
+ arg0 := oit.Event.Arg0 // Make sure unnamed arguments are handled correctly
+ arg1 := oit.Event.Arg1 // Make sure unnamed arguments are handled correctly
+ fmt.Println(arg0, arg1)
+ }
+ // Run a tiny reflection test to ensure disallowed methods don't appear
+ if _, ok := reflect.TypeOf(&EventChecker{}).MethodByName("FilterAnonymous"); ok {
+ t.Errorf("binding has disallowed method (FilterAnonymous)")
+ }`,
+ nil,
+ nil,
+ nil,
+ nil,
+ },
+ // Test that contract interactions (deploy, transact and call) generate working code
+ {
+ `Interactor`,
+ `
+ contract Interactor {
+ string public deployString;
+ string public transactString;
+
+ function Interactor(string str) {
+ deployString = str;
+ }
+
+ function transact(string str) {
+ transactString = str;
+ }
+ }
+ `,
+ []string{`6060604052604051610328380380610328833981016040528051018060006000509080519060200190828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f10608d57805160ff19168380011785555b50607c9291505b8082111560ba57838155600101606b565b50505061026a806100be6000396000f35b828001600101855582156064579182015b828111156064578251826000505591602001919060010190609e565b509056606060405260e060020a60003504630d86a0e181146100315780636874e8091461008d578063d736c513146100ea575b005b610190600180546020600282841615610100026000190190921691909104601f810182900490910260809081016040526060828152929190828280156102295780601f106101fe57610100808354040283529160200191610229565b61019060008054602060026001831615610100026000190190921691909104601f810182900490910260809081016040526060828152929190828280156102295780601f106101fe57610100808354040283529160200191610229565b60206004803580820135601f81018490049093026080908101604052606084815261002f946024939192918401918190838280828437509496505050505050508060016000509080519060200190828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f1061023157805160ff19168380011785555b506102619291505b808211156102665760008155830161017d565b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600f02600301f150905090810190601f1680156101f05780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b820191906000526020600020905b81548152906001019060200180831161020c57829003601f168201915b505050505081565b82800160010185558215610175579182015b82811115610175578251826000505591602001919060010190610243565b505050565b509056`},
+ []string{`[{"constant":true,"inputs":[],"name":"transactString","outputs":[{"name":"","type":"string"}],"type":"function"},{"constant":true,"inputs":[],"name":"deployString","outputs":[{"name":"","type":"string"}],"type":"function"},{"constant":false,"inputs":[{"name":"str","type":"string"}],"name":"transact","outputs":[],"type":"function"},{"inputs":[{"name":"str","type":"string"}],"type":"constructor"}]`},
+ `
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/crypto"
+ `,
+ `
+ // Generate a new random account and a funded simulator
+ key, _ := crypto.GenerateKey()
+ auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
+
+ sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
+ defer sim.Close()
+
+ // Deploy an interaction tester contract and call a transaction on it
+ _, _, interactor, err := DeployInteractor(auth, sim, "Deploy string")
+ if err != nil {
+ t.Fatalf("Failed to deploy interactor contract: %v", err)
+ }
+ if _, err := interactor.Transact(auth, "Transact string"); err != nil {
+ t.Fatalf("Failed to transact with interactor contract: %v", err)
+ }
+ // Commit all pending transactions in the simulator and check the contract state
+ sim.Commit()
+
+ if str, err := interactor.DeployString(nil); err != nil {
+ t.Fatalf("Failed to retrieve deploy string: %v", err)
+ } else if str != "Deploy string" {
+ t.Fatalf("Deploy string mismatch: have '%s', want 'Deploy string'", str)
+ }
+ if str, err := interactor.TransactString(nil); err != nil {
+ t.Fatalf("Failed to retrieve transact string: %v", err)
+ } else if str != "Transact string" {
+ t.Fatalf("Transact string mismatch: have '%s', want 'Transact string'", str)
+ }
+ `,
+ nil,
+ nil,
+ nil,
+ nil,
+ },
+ // Tests that plain values can be properly returned and deserialized
+ {
+ `Getter`,
+ `
+ contract Getter {
+ function getter() constant returns (string, int, bytes32) {
+ return ("Hi", 1, sha3(""));
+ }
+ }
+ `,
+ []string{`606060405260dc8060106000396000f3606060405260e060020a6000350463993a04b78114601a575b005b600060605260c0604052600260809081527f486900000000000000000000000000000000000000000000000000000000000060a05260017fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a47060e0829052610100819052606060c0908152600261012081905281906101409060a09080838184600060046012f1505081517fffff000000000000000000000000000000000000000000000000000000000000169091525050604051610160819003945092505050f3`},
+ []string{`[{"constant":true,"inputs":[],"name":"getter","outputs":[{"name":"","type":"string"},{"name":"","type":"int256"},{"name":"","type":"bytes32"}],"type":"function"}]`},
+ `
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/crypto"
+ `,
+ `
+ // Generate a new random account and a funded simulator
+ key, _ := crypto.GenerateKey()
+ auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
+
+ sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
+ defer sim.Close()
+
+ // Deploy a tuple tester contract and execute a structured call on it
+ _, _, getter, err := DeployGetter(auth, sim)
+ if err != nil {
+ t.Fatalf("Failed to deploy getter contract: %v", err)
+ }
+ sim.Commit()
+
+ if str, num, _, err := getter.Getter(nil); err != nil {
+ t.Fatalf("Failed to call anonymous field retriever: %v", err)
+ } else if str != "Hi" || num.Cmp(big.NewInt(1)) != 0 {
+ t.Fatalf("Retrieved value mismatch: have %v/%v, want %v/%v", str, num, "Hi", 1)
+ }
+ `,
+ nil,
+ nil,
+ nil,
+ nil,
+ },
+ // Tests that tuples can be properly returned and deserialized
+ {
+ `Tupler`,
+ `
+ contract Tupler {
+ function tuple() constant returns (string a, int b, bytes32 c) {
+ return ("Hi", 1, sha3(""));
+ }
+ }
+ `,
+ []string{`606060405260dc8060106000396000f3606060405260e060020a60003504633175aae28114601a575b005b600060605260c0604052600260809081527f486900000000000000000000000000000000000000000000000000000000000060a05260017fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a47060e0829052610100819052606060c0908152600261012081905281906101409060a09080838184600060046012f1505081517fffff000000000000000000000000000000000000000000000000000000000000169091525050604051610160819003945092505050f3`},
+ []string{`[{"constant":true,"inputs":[],"name":"tuple","outputs":[{"name":"a","type":"string"},{"name":"b","type":"int256"},{"name":"c","type":"bytes32"}],"type":"function"}]`},
+ `
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/crypto"
+ `,
+ `
+ // Generate a new random account and a funded simulator
+ key, _ := crypto.GenerateKey()
+ auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
+
+ sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
+ defer sim.Close()
+
+ // Deploy a tuple tester contract and execute a structured call on it
+ _, _, tupler, err := DeployTupler(auth, sim)
+ if err != nil {
+ t.Fatalf("Failed to deploy tupler contract: %v", err)
+ }
+ sim.Commit()
+
+ if res, err := tupler.Tuple(nil); err != nil {
+ t.Fatalf("Failed to call structure retriever: %v", err)
+ } else if res.A != "Hi" || res.B.Cmp(big.NewInt(1)) != 0 {
+ t.Fatalf("Retrieved value mismatch: have %v/%v, want %v/%v", res.A, res.B, "Hi", 1)
+ }
+ `,
+ nil,
+ nil,
+ nil,
+ nil,
+ },
+ // Tests that arrays/slices can be properly returned and deserialized.
+ // Only addresses are tested, remainder just compiled to keep the test small.
+ {
+ `Slicer`,
+ `
+ contract Slicer {
+ function echoAddresses(address[] input) constant returns (address[] output) {
+ return input;
+ }
+ function echoInts(int[] input) constant returns (int[] output) {
+ return input;
+ }
+ function echoFancyInts(uint24[23] input) constant returns (uint24[23] output) {
+ return input;
+ }
+ function echoBools(bool[] input) constant returns (bool[] output) {
+ return input;
+ }
+ }
+ `,
+ []string{`606060405261015c806100126000396000f3606060405260e060020a6000350463be1127a3811461003c578063d88becc014610092578063e15a3db71461003c578063f637e5891461003c575b005b604080516020600480358082013583810285810185019096528085526100ee959294602494909392850192829185019084908082843750949650505050505050604080516020810190915260009052805b919050565b604080516102e0818101909252610138916004916102e491839060179083908390808284375090955050505050506102e0604051908101604052806017905b60008152602001906001900390816100d15790505081905061008d565b60405180806020018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600f02600301f1509050019250505060405180910390f35b60405180826102e0808381846000600461015cf15090500191505060405180910390f3`},
+ []string{`[{"constant":true,"inputs":[{"name":"input","type":"address[]"}],"name":"echoAddresses","outputs":[{"name":"output","type":"address[]"}],"type":"function"},{"constant":true,"inputs":[{"name":"input","type":"uint24[23]"}],"name":"echoFancyInts","outputs":[{"name":"output","type":"uint24[23]"}],"type":"function"},{"constant":true,"inputs":[{"name":"input","type":"int256[]"}],"name":"echoInts","outputs":[{"name":"output","type":"int256[]"}],"type":"function"},{"constant":true,"inputs":[{"name":"input","type":"bool[]"}],"name":"echoBools","outputs":[{"name":"output","type":"bool[]"}],"type":"function"}]`},
+ `
+ "math/big"
+ "reflect"
+
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/crypto"
+ `,
+ `
+ // Generate a new random account and a funded simulator
+ key, _ := crypto.GenerateKey()
+ auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
+
+ sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
+ defer sim.Close()
+
+ // Deploy a slice tester contract and execute a n array call on it
+ _, _, slicer, err := DeploySlicer(auth, sim)
+ if err != nil {
+ t.Fatalf("Failed to deploy slicer contract: %v", err)
+ }
+ sim.Commit()
+
+ if out, err := slicer.EchoAddresses(nil, []common.Address{auth.From, common.Address{}}); err != nil {
+ t.Fatalf("Failed to call slice echoer: %v", err)
+ } else if !reflect.DeepEqual(out, []common.Address{auth.From, common.Address{}}) {
+ t.Fatalf("Slice return mismatch: have %v, want %v", out, []common.Address{auth.From, common.Address{}})
+ }
+ `,
+ nil,
+ nil,
+ nil,
+ nil,
+ },
+ // Tests that anonymous default methods can be correctly invoked
+ {
+ `Defaulter`,
+ `
+ contract Defaulter {
+ address public caller;
+
+ function() {
+ caller = msg.sender;
+ }
+ }
+ `,
+ []string{`6060604052606a8060106000396000f360606040523615601d5760e060020a6000350463fc9c8d3981146040575b605e6000805473ffffffffffffffffffffffffffffffffffffffff191633179055565b606060005473ffffffffffffffffffffffffffffffffffffffff1681565b005b6060908152602090f3`},
+ []string{`[{"constant":true,"inputs":[],"name":"caller","outputs":[{"name":"","type":"address"}],"type":"function"}]`},
+ `
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/crypto"
+ `,
+ `
+ // Generate a new random account and a funded simulator
+ key, _ := crypto.GenerateKey()
+ auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
+
+ sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
+ defer sim.Close()
+
+ // Deploy a default method invoker contract and execute its default method
+ _, _, defaulter, err := DeployDefaulter(auth, sim)
+ if err != nil {
+ t.Fatalf("Failed to deploy defaulter contract: %v", err)
+ }
+ if _, err := (&DefaulterRaw{defaulter}).Transfer(auth); err != nil {
+ t.Fatalf("Failed to invoke default method: %v", err)
+ }
+ sim.Commit()
+
+ if caller, err := defaulter.Caller(nil); err != nil {
+ t.Fatalf("Failed to call address retriever: %v", err)
+ } else if (caller != auth.From) {
+ t.Fatalf("Address mismatch: have %v, want %v", caller, auth.From)
+ }
+ `,
+ nil,
+ nil,
+ nil,
+ nil,
+ },
+ // Tests that structs are correctly unpacked
+ {
+
+ `Structs`,
+ `
+ pragma solidity ^0.6.5;
+ pragma experimental ABIEncoderV2;
+ contract Structs {
+ struct A {
+ bytes32 B;
+ }
+
+ function F() public view returns (A[] memory a, uint256[] memory c, bool[] memory d) {
+ A[] memory a = new A[](2);
+ a[0].B = bytes32(uint256(1234) << 96);
+ uint256[] memory c;
+ bool[] memory d;
+ return (a, c, d);
+ }
+
+ function G() public view returns (A[] memory a) {
+ A[] memory a = new A[](2);
+ a[0].B = bytes32(uint256(1234) << 96);
+ return a;
+ }
+ }
+ `,
+ []string{`608060405234801561001057600080fd5b50610278806100206000396000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c806328811f591461003b5780636fecb6231461005b575b600080fd5b610043610070565b604051610052939291906101a0565b60405180910390f35b6100636100d6565b6040516100529190610186565b604080516002808252606082810190935282918291829190816020015b610095610131565b81526020019060019003908161008d575050805190915061026960611b9082906000906100be57fe5b60209081029190910101515293606093508392509050565b6040805160028082526060828101909352829190816020015b6100f7610131565b8152602001906001900390816100ef575050805190915061026960611b90829060009061012057fe5b602090810291909101015152905090565b60408051602081019091526000815290565b815260200190565b6000815180845260208085019450808401835b8381101561017b578151518752958201959082019060010161015e565b509495945050505050565b600060208252610199602083018461014b565b9392505050565b6000606082526101b3606083018661014b565b6020838203818501528186516101c98185610239565b91508288019350845b818110156101f3576101e5838651610143565b9484019492506001016101d2565b505084810360408601528551808252908201925081860190845b8181101561022b57825115158552938301939183019160010161020d565b509298975050505050505050565b9081526020019056fea2646970667358221220eb85327e285def14230424c52893aebecec1e387a50bb6b75fc4fdbed647f45f64736f6c63430006050033`},
+ []string{`[{"inputs":[],"name":"F","outputs":[{"components":[{"internalType":"bytes32","name":"B","type":"bytes32"}],"internalType":"structStructs.A[]","name":"a","type":"tuple[]"},{"internalType":"uint256[]","name":"c","type":"uint256[]"},{"internalType":"bool[]","name":"d","type":"bool[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"G","outputs":[{"components":[{"internalType":"bytes32","name":"B","type":"bytes32"}],"internalType":"structStructs.A[]","name":"a","type":"tuple[]"}],"stateMutability":"view","type":"function"}]`},
+ `
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/crypto"
+ `,
+ `
+ // Generate a new random account and a funded simulator
+ key, _ := crypto.GenerateKey()
+ auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
+
+ sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
+ defer sim.Close()
+
+ // Deploy a structs method invoker contract and execute its default method
+ _, _, structs, err := DeployStructs(auth, sim)
+ if err != nil {
+ t.Fatalf("Failed to deploy defaulter contract: %v", err)
+ }
+ sim.Commit()
+ opts := bind.CallOpts{}
+ if _, err := structs.F(&opts); err != nil {
+ t.Fatalf("Failed to invoke F method: %v", err)
+ }
+ if _, err := structs.G(&opts); err != nil {
+ t.Fatalf("Failed to invoke G method: %v", err)
+ }
+ `,
+ nil,
+ nil,
+ nil,
+ nil,
+ },
+ // Tests that non-existent contracts are reported as such (though only simulator test)
+ {
+ `NonExistent`,
+ `
+ contract NonExistent {
+ function String() constant returns(string) {
+ return "I don't exist";
+ }
+ }
+ `,
+ []string{`6060604052609f8060106000396000f3606060405260e060020a6000350463f97a60058114601a575b005b600060605260c0604052600d60809081527f4920646f6e27742065786973740000000000000000000000000000000000000060a052602060c0908152600d60e081905281906101009060a09080838184600060046012f15050815172ffffffffffffffffffffffffffffffffffffff1916909152505060405161012081900392509050f3`},
+ []string{`[{"constant":true,"inputs":[],"name":"String","outputs":[{"name":"","type":"string"}],"type":"function"}]`},
+ `
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/core"
+ `,
+ `
+ // Create a simulator and wrap a non-deployed contract
+
+ sim := backends.NewSimulatedBackend(core.GenesisAlloc{}, uint64(10000000000))
+ defer sim.Close()
+
+ nonexistent, err := NewNonExistent(common.Address{}, sim)
+ if err != nil {
+ t.Fatalf("Failed to access non-existent contract: %v", err)
+ }
+ // Ensure that contract calls fail with the appropriate error
+ if res, err := nonexistent.String(nil); err == nil {
+ t.Fatalf("Call succeeded on non-existent contract: %v", res)
+ } else if (err != bind.ErrNoCode) {
+ t.Fatalf("Error mismatch: have %v, want %v", err, bind.ErrNoCode)
+ }
+ `,
+ nil,
+ nil,
+ nil,
+ nil,
+ },
+ {
+ `NonExistentStruct`,
+ `
+ contract NonExistentStruct {
+ function Struct() public view returns(uint256 a, uint256 b) {
+ return (10, 10);
+ }
+ }
+ `,
+ []string{`6080604052348015600f57600080fd5b5060888061001e6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063d5f6622514602d575b600080fd5b6033604c565b6040805192835260208301919091528051918290030190f35b600a809156fea264697066735822beefbeefbeefbeefbeefbeefbeefbeefbeefbeefbeefbeefbeefbeefbeefbeefbeef64736f6c6343decafe0033`},
+ []string{`[{"inputs":[],"name":"Struct","outputs":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256","name":"b","type":"uint256"}],"stateMutability":"pure","type":"function"}]`},
+ `
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/core"
+ `,
+ `
+ // Create a simulator and wrap a non-deployed contract
+
+ sim := backends.NewSimulatedBackend(core.GenesisAlloc{}, uint64(10000000000))
+ defer sim.Close()
+
+ nonexistent, err := NewNonExistentStruct(common.Address{}, sim)
+ if err != nil {
+ t.Fatalf("Failed to access non-existent contract: %v", err)
+ }
+ // Ensure that contract calls fail with the appropriate error
+ if res, err := nonexistent.Struct(nil); err == nil {
+ t.Fatalf("Call succeeded on non-existent contract: %v", res)
+ } else if (err != bind.ErrNoCode) {
+ t.Fatalf("Error mismatch: have %v, want %v", err, bind.ErrNoCode)
+ }
+ `,
+ nil,
+ nil,
+ nil,
+ nil,
+ },
+ // Tests that gas estimation works for contracts with weird gas mechanics too.
+ {
+ `FunkyGasPattern`,
+ `
+ contract FunkyGasPattern {
+ string public field;
+
+ function SetField(string value) {
+ // This check will screw gas estimation! Good, good!
+ if (msg.gas < 100000) {
+ throw;
+ }
+ field = value;
+ }
+ }
+ `,
+ []string{`606060405261021c806100126000396000f3606060405260e060020a600035046323fcf32a81146100265780634f28bf0e1461007b575b005b6040805160206004803580820135601f8101849004840285018401909552848452610024949193602493909291840191908190840183828082843750949650505050505050620186a05a101561014e57610002565b6100db60008054604080516020601f600260001961010060018816150201909516949094049384018190048102820181019092528281529291908301828280156102145780601f106101e957610100808354040283529160200191610214565b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f16801561013b5780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b505050565b8060006000509080519060200190828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f106101b557805160ff19168380011785555b506101499291505b808211156101e557600081556001016101a1565b82800160010185558215610199579182015b828111156101995782518260005055916020019190600101906101c7565b5090565b820191906000526020600020905b8154815290600101906020018083116101f757829003601f168201915b50505050508156`},
+ []string{`[{"constant":false,"inputs":[{"name":"value","type":"string"}],"name":"SetField","outputs":[],"type":"function"},{"constant":true,"inputs":[],"name":"field","outputs":[{"name":"","type":"string"}],"type":"function"}]`},
+ `
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/crypto"
+ `,
+ `
+ // Generate a new random account and a funded simulator
+ key, _ := crypto.GenerateKey()
+ auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
+
+ sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
+ defer sim.Close()
+
+ // Deploy a funky gas pattern contract
+ _, _, limiter, err := DeployFunkyGasPattern(auth, sim)
+ if err != nil {
+ t.Fatalf("Failed to deploy funky contract: %v", err)
+ }
+ sim.Commit()
+
+ // Set the field with automatic estimation and check that it succeeds
+ if _, err := limiter.SetField(auth, "automatic"); err != nil {
+ t.Fatalf("Failed to call automatically gased transaction: %v", err)
+ }
+ sim.Commit()
+
+ if field, _ := limiter.Field(nil); field != "automatic" {
+ t.Fatalf("Field mismatch: have %v, want %v", field, "automatic")
+ }
+ `,
+ nil,
+ nil,
+ nil,
+ nil,
+ },
+ // Test that constant functions can be called from an (optional) specified address
+ {
+ `CallFrom`,
+ `
+ contract CallFrom {
+ function callFrom() constant returns(address) {
+ return msg.sender;
+ }
+ }
+ `, []string{`6060604052346000575b6086806100176000396000f300606060405263ffffffff60e060020a60003504166349f8e98281146022575b6000565b34600057602c6055565b6040805173ffffffffffffffffffffffffffffffffffffffff9092168252519081900360200190f35b335b905600a165627a7a72305820aef6b7685c0fa24ba6027e4870404a57df701473fe4107741805c19f5138417c0029`},
+ []string{`[{"constant":true,"inputs":[],"name":"callFrom","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"}]`},
+ `
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/crypto"
+ `,
+ `
+ // Generate a new random account and a funded simulator
+ key, _ := crypto.GenerateKey()
+ auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
+
+ sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
+ defer sim.Close()
+
+ // Deploy a sender tester contract and execute a structured call on it
+ _, _, callfrom, err := DeployCallFrom(auth, sim)
+ if err != nil {
+ t.Fatalf("Failed to deploy sender contract: %v", err)
+ }
+ sim.Commit()
+
+ if res, err := callfrom.CallFrom(nil); err != nil {
+ t.Errorf("Failed to call constant function: %v", err)
+ } else if res != (common.Address{}) {
+ t.Errorf("Invalid address returned, want: %x, got: %x", (common.Address{}), res)
+ }
+
+ for _, addr := range []common.Address{common.Address{}, common.Address{1}, common.Address{2}} {
+ if res, err := callfrom.CallFrom(&bind.CallOpts{From: addr}); err != nil {
+ t.Fatalf("Failed to call constant function: %v", err)
+ } else if res != addr {
+ t.Fatalf("Invalid address returned, want: %x, got: %x", addr, res)
+ }
+ }
+ `,
+ nil,
+ nil,
+ nil,
+ nil,
+ },
+ // Tests that methods and returns with underscores inside work correctly.
+ {
+ `Underscorer`,
+ `
+ contract Underscorer {
+ function UnderscoredOutput() constant returns (int _int, string _string) {
+ return (314, "pi");
+ }
+ function LowerLowerCollision() constant returns (int _res, int res) {
+ return (1, 2);
+ }
+ function LowerUpperCollision() constant returns (int _res, int Res) {
+ return (1, 2);
+ }
+ function UpperLowerCollision() constant returns (int _Res, int res) {
+ return (1, 2);
+ }
+ function UpperUpperCollision() constant returns (int _Res, int Res) {
+ return (1, 2);
+ }
+ function PurelyUnderscoredOutput() constant returns (int _, int res) {
+ return (1, 2);
+ }
+ function AllPurelyUnderscoredOutput() constant returns (int _, int __) {
+ return (1, 2);
+ }
+ function _under_scored_func() constant returns (int _int) {
+ return 0;
+ }
+ }
+ `, []string{`6060604052341561000f57600080fd5b6103858061001e6000396000f30060606040526004361061008e576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806303a592131461009357806346546dbe146100c357806367e6633d146100ec5780639df4848514610181578063af7486ab146101b1578063b564b34d146101e1578063e02ab24d14610211578063e409ca4514610241575b600080fd5b341561009e57600080fd5b6100a6610271565b604051808381526020018281526020019250505060405180910390f35b34156100ce57600080fd5b6100d6610286565b6040518082815260200191505060405180910390f35b34156100f757600080fd5b6100ff61028e565b6040518083815260200180602001828103825283818151815260200191508051906020019080838360005b8381101561014557808201518184015260208101905061012a565b50505050905090810190601f1680156101725780820380516001836020036101000a031916815260200191505b50935050505060405180910390f35b341561018c57600080fd5b6101946102dc565b604051808381526020018281526020019250505060405180910390f35b34156101bc57600080fd5b6101c46102f1565b604051808381526020018281526020019250505060405180910390f35b34156101ec57600080fd5b6101f4610306565b604051808381526020018281526020019250505060405180910390f35b341561021c57600080fd5b61022461031b565b604051808381526020018281526020019250505060405180910390f35b341561024c57600080fd5b610254610330565b604051808381526020018281526020019250505060405180910390f35b60008060016002819150809050915091509091565b600080905090565b6000610298610345565b61013a8090506040805190810160405280600281526020017f7069000000000000000000000000000000000000000000000000000000000000815250915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b6020604051908101604052806000815250905600a165627a7a72305820d1a53d9de9d1e3d55cb3dc591900b63c4f1ded79114f7b79b332684840e186a40029`},
+ []string{`[{"constant":true,"inputs":[],"name":"LowerUpperCollision","outputs":[{"name":"_res","type":"int256"},{"name":"Res","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"_under_scored_func","outputs":[{"name":"_int","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"UnderscoredOutput","outputs":[{"name":"_int","type":"int256"},{"name":"_string","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"PurelyUnderscoredOutput","outputs":[{"name":"_","type":"int256"},{"name":"res","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"UpperLowerCollision","outputs":[{"name":"_Res","type":"int256"},{"name":"res","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"AllPurelyUnderscoredOutput","outputs":[{"name":"_","type":"int256"},{"name":"__","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"UpperUpperCollision","outputs":[{"name":"_Res","type":"int256"},{"name":"Res","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"LowerLowerCollision","outputs":[{"name":"_res","type":"int256"},{"name":"res","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"}]`},
+ `
+ "fmt"
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/crypto"
+ `,
+ `
+ // Generate a new random account and a funded simulator
+ key, _ := crypto.GenerateKey()
+ auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
+
+ sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
+ defer sim.Close()
+
+ // Deploy a underscorer tester contract and execute a structured call on it
+ _, _, underscorer, err := DeployUnderscorer(auth, sim)
+ if err != nil {
+ t.Fatalf("Failed to deploy underscorer contract: %v", err)
+ }
+ sim.Commit()
+
+ // Verify that underscored return values correctly parse into structs
+ if res, err := underscorer.UnderscoredOutput(nil); err != nil {
+ t.Errorf("Failed to call constant function: %v", err)
+ } else if res.Int.Cmp(big.NewInt(314)) != 0 || res.String != "pi" {
+ t.Errorf("Invalid result, want: {314, \"pi\"}, got: %+v", res)
+ }
+ // Verify that underscored and non-underscored name collisions force tuple outputs
+ var a, b *big.Int
+
+ a, b, _ = underscorer.LowerLowerCollision(nil)
+ a, b, _ = underscorer.LowerUpperCollision(nil)
+ a, b, _ = underscorer.UpperLowerCollision(nil)
+ a, b, _ = underscorer.UpperUpperCollision(nil)
+ a, b, _ = underscorer.PurelyUnderscoredOutput(nil)
+ a, b, _ = underscorer.AllPurelyUnderscoredOutput(nil)
+ a, _ = underscorer.UnderScoredFunc(nil)
+
+ fmt.Println(a, b, err)
+ `,
+ nil,
+ nil,
+ nil,
+ nil,
+ },
+ // Tests that logs can be successfully filtered and decoded.
+ {
+ `Eventer`,
+ `
+ contract Eventer {
+ event SimpleEvent (
+ address indexed Addr,
+ bytes32 indexed Id,
+ bool indexed Flag,
+ uint Value
+ );
+ function raiseSimpleEvent(address addr, bytes32 id, bool flag, uint value) {
+ SimpleEvent(addr, id, flag, value);
+ }
+
+ event NodataEvent (
+ uint indexed Number,
+ int16 indexed Short,
+ uint32 indexed Long
+ );
+ function raiseNodataEvent(uint number, int16 short, uint32 long) {
+ NodataEvent(number, short, long);
+ }
+
+ event DynamicEvent (
+ string indexed IndexedString,
+ bytes indexed IndexedBytes,
+ string NonIndexedString,
+ bytes NonIndexedBytes
+ );
+ function raiseDynamicEvent(string str, bytes blob) {
+ DynamicEvent(str, blob, str, blob);
+ }
+
+ event FixedBytesEvent (
+ bytes24 indexed IndexedBytes,
+ bytes24 NonIndexedBytes
+ );
+ function raiseFixedBytesEvent(bytes24 blob) {
+ FixedBytesEvent(blob, blob);
+ }
+ }
+ `,
+ []string{`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`},
+ []string{`[{"constant":false,"inputs":[{"name":"str","type":"string"},{"name":"blob","type":"bytes"}],"name":"raiseDynamicEvent","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"addr","type":"address"},{"name":"id","type":"bytes32"},{"name":"flag","type":"bool"},{"name":"value","type":"uint256"}],"name":"raiseSimpleEvent","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"blob","type":"bytes24"}],"name":"raiseFixedBytesEvent","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"number","type":"uint256"},{"name":"short","type":"int16"},{"name":"long","type":"uint32"}],"name":"raiseNodataEvent","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"anonymous":false,"inputs":[{"indexed":true,"name":"Addr","type":"address"},{"indexed":true,"name":"Id","type":"bytes32"},{"indexed":true,"name":"Flag","type":"bool"},{"indexed":false,"name":"Value","type":"uint256"}],"name":"SimpleEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"Number","type":"uint256"},{"indexed":true,"name":"Short","type":"int16"},{"indexed":true,"name":"Long","type":"uint32"}],"name":"NodataEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"IndexedString","type":"string"},{"indexed":true,"name":"IndexedBytes","type":"bytes"},{"indexed":false,"name":"NonIndexedString","type":"string"},{"indexed":false,"name":"NonIndexedBytes","type":"bytes"}],"name":"DynamicEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"IndexedBytes","type":"bytes24"},{"indexed":false,"name":"NonIndexedBytes","type":"bytes24"}],"name":"FixedBytesEvent","type":"event"}]`},
+ `
+ "math/big"
+ "time"
+
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/crypto"
+ `,
+ `
+ // Generate a new random account and a funded simulator
+ key, _ := crypto.GenerateKey()
+ auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
+
+ sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
+ defer sim.Close()
+
+ // Deploy an eventer contract
+ _, _, eventer, err := DeployEventer(auth, sim)
+ if err != nil {
+ t.Fatalf("Failed to deploy eventer contract: %v", err)
+ }
+ sim.Commit()
+
+ // Inject a few events into the contract, gradually more in each block
+ for i := 1; i <= 3; i++ {
+ for j := 1; j <= i; j++ {
+ if _, err := eventer.RaiseSimpleEvent(auth, common.Address{byte(j)}, [32]byte{byte(j)}, true, big.NewInt(int64(10*i+j))); err != nil {
+ t.Fatalf("block %d, event %d: raise failed: %v", i, j, err)
+ }
+ }
+ sim.Commit()
+ }
+ // Test filtering for certain events and ensure they can be found
+ sit, err := eventer.FilterSimpleEvent(nil, []common.Address{common.Address{1}, common.Address{3}}, [][32]byte{{byte(1)}, {byte(2)}, {byte(3)}}, []bool{true})
+ if err != nil {
+ t.Fatalf("failed to filter for simple events: %v", err)
+ }
+ defer sit.Close()
+
+ sit.Next()
+ if sit.Event.Value.Uint64() != 11 || !sit.Event.Flag {
+ t.Errorf("simple log content mismatch: have %v, want {11, true}", sit.Event)
+ }
+ sit.Next()
+ if sit.Event.Value.Uint64() != 21 || !sit.Event.Flag {
+ t.Errorf("simple log content mismatch: have %v, want {21, true}", sit.Event)
+ }
+ sit.Next()
+ if sit.Event.Value.Uint64() != 31 || !sit.Event.Flag {
+ t.Errorf("simple log content mismatch: have %v, want {31, true}", sit.Event)
+ }
+ sit.Next()
+ if sit.Event.Value.Uint64() != 33 || !sit.Event.Flag {
+ t.Errorf("simple log content mismatch: have %v, want {33, true}", sit.Event)
+ }
+
+ if sit.Next() {
+ t.Errorf("unexpected simple event found: %+v", sit.Event)
+ }
+ if err = sit.Error(); err != nil {
+ t.Fatalf("simple event iteration failed: %v", err)
+ }
+ // Test raising and filtering for an event with no data component
+ if _, err := eventer.RaiseNodataEvent(auth, big.NewInt(314), 141, 271); err != nil {
+ t.Fatalf("failed to raise nodata event: %v", err)
+ }
+ sim.Commit()
+
+ nit, err := eventer.FilterNodataEvent(nil, []*big.Int{big.NewInt(314)}, []int16{140, 141, 142}, []uint32{271})
+ if err != nil {
+ t.Fatalf("failed to filter for nodata events: %v", err)
+ }
+ defer nit.Close()
+
+ if !nit.Next() {
+ t.Fatalf("nodata log not found: %v", nit.Error())
+ }
+ if nit.Event.Number.Uint64() != 314 {
+ t.Errorf("nodata log content mismatch: have %v, want 314", nit.Event.Number)
+ }
+ if nit.Next() {
+ t.Errorf("unexpected nodata event found: %+v", nit.Event)
+ }
+ if err = nit.Error(); err != nil {
+ t.Fatalf("nodata event iteration failed: %v", err)
+ }
+ // Test raising and filtering for events with dynamic indexed components
+ if _, err := eventer.RaiseDynamicEvent(auth, "Hello", []byte("World")); err != nil {
+ t.Fatalf("failed to raise dynamic event: %v", err)
+ }
+ sim.Commit()
+
+ dit, err := eventer.FilterDynamicEvent(nil, []string{"Hi", "Hello", "Bye"}, [][]byte{[]byte("World")})
+ if err != nil {
+ t.Fatalf("failed to filter for dynamic events: %v", err)
+ }
+ defer dit.Close()
+
+ if !dit.Next() {
+ t.Fatalf("dynamic log not found: %v", dit.Error())
+ }
+ if dit.Event.NonIndexedString != "Hello" || string(dit.Event.NonIndexedBytes) != "World" || dit.Event.IndexedString != common.HexToHash("0x06b3dfaec148fb1bb2b066f10ec285e7c9bf402ab32aa78a5d38e34566810cd2") || dit.Event.IndexedBytes != common.HexToHash("0xf2208c967df089f60420785795c0a9ba8896b0f6f1867fa7f1f12ad6f79c1a18") {
+ t.Errorf("dynamic log content mismatch: have %v, want {'0x06b3dfaec148fb1bb2b066f10ec285e7c9bf402ab32aa78a5d38e34566810cd2, '0xf2208c967df089f60420785795c0a9ba8896b0f6f1867fa7f1f12ad6f79c1a18', 'Hello', 'World'}", dit.Event)
+ }
+ if dit.Next() {
+ t.Errorf("unexpected dynamic event found: %+v", dit.Event)
+ }
+ if err = dit.Error(); err != nil {
+ t.Fatalf("dynamic event iteration failed: %v", err)
+ }
+ // Test raising and filtering for events with fixed bytes components
+ var fblob [24]byte
+ copy(fblob[:], []byte("Fixed Bytes"))
+
+ if _, err := eventer.RaiseFixedBytesEvent(auth, fblob); err != nil {
+ t.Fatalf("failed to raise fixed bytes event: %v", err)
+ }
+ sim.Commit()
+
+ fit, err := eventer.FilterFixedBytesEvent(nil, [][24]byte{fblob})
+ if err != nil {
+ t.Fatalf("failed to filter for fixed bytes events: %v", err)
+ }
+ defer fit.Close()
+
+ if !fit.Next() {
+ t.Fatalf("fixed bytes log not found: %v", fit.Error())
+ }
+ if fit.Event.NonIndexedBytes != fblob || fit.Event.IndexedBytes != fblob {
+ t.Errorf("fixed bytes log content mismatch: have %v, want {'%x', '%x'}", fit.Event, fblob, fblob)
+ }
+ if fit.Next() {
+ t.Errorf("unexpected fixed bytes event found: %+v", fit.Event)
+ }
+ if err = fit.Error(); err != nil {
+ t.Fatalf("fixed bytes event iteration failed: %v", err)
+ }
+ // Test subscribing to an event and raising it afterwards
+ ch := make(chan *EventerSimpleEvent, 16)
+ sub, err := eventer.WatchSimpleEvent(nil, ch, nil, nil, nil)
+ if err != nil {
+ t.Fatalf("failed to subscribe to simple events: %v", err)
+ }
+ if _, err := eventer.RaiseSimpleEvent(auth, common.Address{255}, [32]byte{255}, true, big.NewInt(255)); err != nil {
+ t.Fatalf("failed to raise subscribed simple event: %v", err)
+ }
+ sim.Commit()
+
+ select {
+ case event := <-ch:
+ if event.Value.Uint64() != 255 {
+ t.Errorf("simple log content mismatch: have %v, want 255", event)
+ }
+ case <-time.After(250 * time.Millisecond):
+ t.Fatalf("subscribed simple event didn't arrive")
+ }
+ // Unsubscribe from the event and make sure we're not delivered more
+ sub.Unsubscribe()
+
+ if _, err := eventer.RaiseSimpleEvent(auth, common.Address{254}, [32]byte{254}, true, big.NewInt(254)); err != nil {
+ t.Fatalf("failed to raise subscribed simple event: %v", err)
+ }
+ sim.Commit()
+
+ select {
+ case event := <-ch:
+ t.Fatalf("unsubscribed simple event arrived: %v", event)
+ case <-time.After(250 * time.Millisecond):
+ }
+ `,
+ nil,
+ nil,
+ nil,
+ nil,
+ },
+ {
+ `DeeplyNestedArray`,
+ `
+ contract DeeplyNestedArray {
+ uint64[3][4][5] public deepUint64Array;
+ function storeDeepUintArray(uint64[3][4][5] arr) public {
+ deepUint64Array = arr;
+ }
+ function retrieveDeepArray() public view returns (uint64[3][4][5]) {
+ return deepUint64Array;
+ }
+ }
+ `,
+ []string{`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`},
+ []string{`[{"constant":false,"inputs":[{"name":"arr","type":"uint64[3][4][5]"}],"name":"storeDeepUintArray","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"retrieveDeepArray","outputs":[{"name":"","type":"uint64[3][4][5]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"},{"name":"","type":"uint256"},{"name":"","type":"uint256"}],"name":"deepUint64Array","outputs":[{"name":"","type":"uint64"}],"payable":false,"stateMutability":"view","type":"function"}]`},
+ `
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/crypto"
+ `,
+ `
+ // Generate a new random account and a funded simulator
+ key, _ := crypto.GenerateKey()
+ auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
+
+ sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
+ defer sim.Close()
+
+ //deploy the test contract
+ _, _, testContract, err := DeployDeeplyNestedArray(auth, sim)
+ if err != nil {
+ t.Fatalf("Failed to deploy test contract: %v", err)
+ }
+
+ // Finish deploy.
+ sim.Commit()
+
+ //Create coordinate-filled array, for testing purposes.
+ testArr := [5][4][3]uint64{}
+ for i := 0; i < 5; i++ {
+ testArr[i] = [4][3]uint64{}
+ for j := 0; j < 4; j++ {
+ testArr[i][j] = [3]uint64{}
+ for k := 0; k < 3; k++ {
+ //pack the coordinates, each array value will be unique, and can be validated easily.
+ testArr[i][j][k] = uint64(i) << 16 | uint64(j) << 8 | uint64(k)
+ }
+ }
+ }
+
+ if _, err := testContract.StoreDeepUintArray(&bind.TransactOpts{
+ From: auth.From,
+ Signer: auth.Signer,
+ }, testArr); err != nil {
+ t.Fatalf("Failed to store nested array in test contract: %v", err)
+ }
+
+ sim.Commit()
+
+ retrievedArr, err := testContract.RetrieveDeepArray(&bind.CallOpts{
+ From: auth.From,
+ Pending: false,
+ })
+ if err != nil {
+ t.Fatalf("Failed to retrieve nested array from test contract: %v", err)
+ }
+
+ //quick check to see if contents were copied
+ // (See accounts/abi/unpack_test.go for more extensive testing)
+ if retrievedArr[4][3][2] != testArr[4][3][2] {
+ t.Fatalf("Retrieved value does not match expected value! got: %d, expected: %d. %v", retrievedArr[4][3][2], testArr[4][3][2], err)
+ }
+ `,
+ nil,
+ nil,
+ nil,
+ nil,
+ },
+ {
+ `CallbackParam`,
+ `
+ contract FunctionPointerTest {
+ function test(function(uint256) external callback) external {
+ callback(1);
+ }
+ }
+ `,
+ []string{`608060405234801561001057600080fd5b5061015e806100206000396000f3fe60806040526004361061003b576000357c010000000000000000000000000000000000000000000000000000000090048063d7a5aba214610040575b600080fd5b34801561004c57600080fd5b506100be6004803603602081101561006357600080fd5b810190808035806c0100000000000000000000000090049068010000000000000000900463ffffffff1677ffffffffffffffffffffffffffffffffffffffffffffffff169091602001919093929190939291905050506100c0565b005b818160016040518263ffffffff167c010000000000000000000000000000000000000000000000000000000002815260040180828152602001915050600060405180830381600087803b15801561011657600080fd5b505af115801561012a573d6000803e3d6000fd5b50505050505056fea165627a7a7230582062f87455ff84be90896dbb0c4e4ddb505c600d23089f8e80a512548440d7e2580029`},
+ []string{`[
+ {
+ "constant": false,
+ "inputs": [
+ {
+ "name": "callback",
+ "type": "function"
+ }
+ ],
+ "name": "test",
+ "outputs": [],
+ "payable": false,
+ "stateMutability": "nonpayable",
+ "type": "function"
+ }
+ ]`}, `
+ "strings"
+ `,
+ `
+ if strings.Compare("test(function)", CallbackParamFuncSigs["d7a5aba2"]) != 0 {
+ t.Fatalf("")
+ }
+ `,
+ []map[string]string{
+ {
+ "test(function)": "d7a5aba2",
+ },
+ },
+ nil,
+ nil,
+ nil,
+ }, {
+ `Tuple`,
+ `
+ pragma solidity >=0.4.19 <0.6.0;
+ pragma experimental ABIEncoderV2;
+
+ contract Tuple {
+ struct S { uint a; uint[] b; T[] c; }
+ struct T { uint x; uint y; }
+ struct P { uint8 x; uint8 y; }
+ struct Q { uint16 x; uint16 y; }
+ event TupleEvent(S a, T[2][] b, T[][2] c, S[] d, uint[] e);
+ event TupleEvent2(P[]);
+
+ function func1(S memory a, T[2][] memory b, T[][2] memory c, S[] memory d, uint[] memory e) public pure returns (S memory, T[2][] memory, T[][2] memory, S[] memory, uint[] memory) {
+ return (a, b, c, d, e);
+ }
+ function func2(S memory a, T[2][] memory b, T[][2] memory c, S[] memory d, uint[] memory e) public {
+ emit TupleEvent(a, b, c, d, e);
+ }
+ function func3(Q[] memory) public pure {} // call function, nothing to return
+ }
+ `,
+ []string{`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`},
+ []string{`
+[{"anonymous":false,"inputs":[{"components":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256[]","name":"b","type":"uint256[]"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[]","name":"c","type":"tuple[]"}],"indexed":false,"internalType":"struct Tuple.S","name":"a","type":"tuple"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"indexed":false,"internalType":"struct Tuple.T[2][]","name":"b","type":"tuple[2][]"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"indexed":false,"internalType":"struct Tuple.T[][2]","name":"c","type":"tuple[][2]"},{"components":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256[]","name":"b","type":"uint256[]"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[]","name":"c","type":"tuple[]"}],"indexed":false,"internalType":"struct Tuple.S[]","name":"d","type":"tuple[]"},{"indexed":false,"internalType":"uint256[]","name":"e","type":"uint256[]"}],"name":"TupleEvent","type":"event"},{"anonymous":false,"inputs":[{"components":[{"internalType":"uint8","name":"x","type":"uint8"},{"internalType":"uint8","name":"y","type":"uint8"}],"indexed":false,"internalType":"struct Tuple.P[]","name":"","type":"tuple[]"}],"name":"TupleEvent2","type":"event"},{"constant":true,"inputs":[{"components":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256[]","name":"b","type":"uint256[]"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[]","name":"c","type":"tuple[]"}],"internalType":"struct Tuple.S","name":"a","type":"tuple"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[2][]","name":"b","type":"tuple[2][]"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[][2]","name":"c","type":"tuple[][2]"},{"components":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256[]","name":"b","type":"uint256[]"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[]","name":"c","type":"tuple[]"}],"internalType":"struct Tuple.S[]","name":"d","type":"tuple[]"},{"internalType":"uint256[]","name":"e","type":"uint256[]"}],"name":"func1","outputs":[{"components":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256[]","name":"b","type":"uint256[]"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[]","name":"c","type":"tuple[]"}],"internalType":"struct Tuple.S","name":"","type":"tuple"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[2][]","name":"","type":"tuple[2][]"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[][2]","name":"","type":"tuple[][2]"},{"components":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256[]","name":"b","type":"uint256[]"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[]","name":"c","type":"tuple[]"}],"internalType":"struct Tuple.S[]","name":"","type":"tuple[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"}],"payable":false,"stateMutability":"pure","type":"function"},{"constant":false,"inputs":[{"components":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256[]","name":"b","type":"uint256[]"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[]","name":"c","type":"tuple[]"}],"internalType":"struct Tuple.S","name":"a","type":"tuple"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[2][]","name":"b","type":"tuple[2][]"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[][2]","name":"c","type":"tuple[][2]"},{"components":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256[]","name":"b","type":"uint256[]"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[]","name":"c","type":"tuple[]"}],"internalType":"struct Tuple.S[]","name":"d","type":"tuple[]"},{"internalType":"uint256[]","name":"e","type":"uint256[]"}],"name":"func2","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"components":[{"internalType":"uint16","name":"x","type":"uint16"},{"internalType":"uint16","name":"y","type":"uint16"}],"internalType":"struct Tuple.Q[]","name":"","type":"tuple[]"}],"name":"func3","outputs":[],"payable":false,"stateMutability":"pure","type":"function"}]
+ `},
+ `
+ "math/big"
+ "reflect"
+
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/crypto"
+ `,
+
+ `
+ key, _ := crypto.GenerateKey()
+ auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
+
+ sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
+ defer sim.Close()
+
+ _, _, contract, err := DeployTuple(auth, sim)
+ if err != nil {
+ t.Fatalf("deploy contract failed %v", err)
+ }
+ sim.Commit()
+
+ check := func(a, b interface{}, errMsg string) {
+ if !reflect.DeepEqual(a, b) {
+ t.Fatal(errMsg)
+ }
+ }
+
+ a := TupleS{
+ A: big.NewInt(1),
+ B: []*big.Int{big.NewInt(2), big.NewInt(3)},
+ C: []TupleT{
+ {
+ X: big.NewInt(4),
+ Y: big.NewInt(5),
+ },
+ {
+ X: big.NewInt(6),
+ Y: big.NewInt(7),
+ },
+ },
+ }
+
+ b := [][2]TupleT{
+ {
+ {
+ X: big.NewInt(8),
+ Y: big.NewInt(9),
+ },
+ {
+ X: big.NewInt(10),
+ Y: big.NewInt(11),
+ },
+ },
+ }
+
+ c := [2][]TupleT{
+ {
+ {
+ X: big.NewInt(12),
+ Y: big.NewInt(13),
+ },
+ {
+ X: big.NewInt(14),
+ Y: big.NewInt(15),
+ },
+ },
+ {
+ {
+ X: big.NewInt(16),
+ Y: big.NewInt(17),
+ },
+ },
+ }
+
+ d := []TupleS{a}
+
+ e := []*big.Int{big.NewInt(18), big.NewInt(19)}
+ ret1, ret2, ret3, ret4, ret5, err := contract.Func1(nil, a, b, c, d, e)
+ if err != nil {
+ t.Fatalf("invoke contract failed, err %v", err)
+ }
+ check(ret1, a, "ret1 mismatch")
+ check(ret2, b, "ret2 mismatch")
+ check(ret3, c, "ret3 mismatch")
+ check(ret4, d, "ret4 mismatch")
+ check(ret5, e, "ret5 mismatch")
+
+ _, err = contract.Func2(auth, a, b, c, d, e)
+ if err != nil {
+ t.Fatalf("invoke contract failed, err %v", err)
+ }
+ sim.Commit()
+
+ iter, err := contract.FilterTupleEvent(nil)
+ if err != nil {
+ t.Fatalf("failed to create event filter, err %v", err)
+ }
+ defer iter.Close()
+
+ iter.Next()
+ check(iter.Event.A, a, "field1 mismatch")
+ check(iter.Event.B, b, "field2 mismatch")
+ check(iter.Event.C, c, "field3 mismatch")
+ check(iter.Event.D, d, "field4 mismatch")
+ check(iter.Event.E, e, "field5 mismatch")
+
+ err = contract.Func3(nil, nil)
+ if err != nil {
+ t.Fatalf("failed to call function which has no return, err %v", err)
+ }
+ `,
+ nil,
+ nil,
+ nil,
+ nil,
+ },
+ {
+ `UseLibrary`,
+ `
+ library Math {
+ function add(uint a, uint b) public view returns(uint) {
+ return a + b;
+ }
+ }
+
+ contract UseLibrary {
+ function add (uint c, uint d) public view returns(uint) {
+ return Math.add(c,d);
+ }
+ }
+ `,
+ []string{
+ // Bytecode for the UseLibrary contract
+ `608060405234801561001057600080fd5b5061011d806100206000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063771602f714602d575b600080fd5b604d60048036036040811015604157600080fd5b5080359060200135605f565b60408051918252519081900360200190f35b600073__$b98c933f0a6ececcd167bd4f9d3299b1a0$__63771602f784846040518363ffffffff1660e01b8152600401808381526020018281526020019250505060206040518083038186803b15801560b757600080fd5b505af415801560ca573d6000803e3d6000fd5b505050506040513d602081101560df57600080fd5b5051939250505056fea265627a7a72305820eb5c38f42445604cfa43d85e3aa5ecc48b0a646456c902dd48420ae7241d06f664736f6c63430005090032`,
+ // Bytecode for the Math contract
+ `60a3610024600b82828239805160001a607314601757fe5b30600052607381538281f3fe730000000000000000000000000000000000000000301460806040526004361060335760003560e01c8063771602f7146038575b600080fd5b605860048036036040811015604c57600080fd5b5080359060200135606a565b60408051918252519081900360200190f35b019056fea265627a7a723058206fc6c05f3078327f9c763edffdb5ab5f8bd212e293a1306c7d0ad05af3ad35f464736f6c63430005090032`,
+ },
+ []string{
+ `[{"constant":true,"inputs":[{"name":"c","type":"uint256"},{"name":"d","type":"uint256"}],"name":"add","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"}]`,
+ `[{"constant":true,"inputs":[{"name":"a","type":"uint256"},{"name":"b","type":"uint256"}],"name":"add","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"}]`,
+ },
+ `
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/crypto"
+ `,
+ `
+ // Generate a new random account and a funded simulator
+ key, _ := crypto.GenerateKey()
+ auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
+
+ sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
+ defer sim.Close()
+
+ //deploy the test contract
+ _, _, testContract, err := DeployUseLibrary(auth, sim)
+ if err != nil {
+ t.Fatalf("Failed to deploy test contract: %v", err)
+ }
+
+ // Finish deploy.
+ sim.Commit()
+
+ // Check that the library contract has been deployed
+ // by calling the contract's add function.
+ res, err := testContract.Add(&bind.CallOpts{
+ From: auth.From,
+ Pending: false,
+ }, big.NewInt(1), big.NewInt(2))
+ if err != nil {
+ t.Fatalf("Failed to call linked contract: %v", err)
+ }
+ if res.Cmp(big.NewInt(3)) != 0 {
+ t.Fatalf("Add did not return the correct result: %d != %d", res, 3)
+ }
+ `,
+ nil,
+ map[string]string{
+ "b98c933f0a6ececcd167bd4f9d3299b1a0": "Math",
+ },
+ nil,
+ []string{"UseLibrary", "Math"},
+ }, {
+ "Overload",
+ `
+ pragma solidity ^0.5.10;
+
+ contract overload {
+ mapping(address => uint256) balances;
+
+ event bar(uint256 i);
+ event bar(uint256 i, uint256 j);
+
+ function foo(uint256 i) public {
+ emit bar(i);
+ }
+ function foo(uint256 i, uint256 j) public {
+ emit bar(i, j);
+ }
+ }
+ `,
+ []string{`608060405234801561001057600080fd5b50610153806100206000396000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c806304bc52f81461003b5780632fbebd3814610073575b600080fd5b6100716004803603604081101561005157600080fd5b8101908080359060200190929190803590602001909291905050506100a1565b005b61009f6004803603602081101561008957600080fd5b81019080803590602001909291905050506100e4565b005b7fae42e9514233792a47a1e4554624e83fe852228e1503f63cd383e8a431f4f46d8282604051808381526020018281526020019250505060405180910390a15050565b7f0423a1321222a0a8716c22b92fac42d85a45a612b696a461784d9fa537c81e5c816040518082815260200191505060405180910390a15056fea265627a7a72305820e22b049858b33291cbe67eeaece0c5f64333e439d27032ea8337d08b1de18fe864736f6c634300050a0032`},
+ []string{`[{"constant":false,"inputs":[{"name":"i","type":"uint256"},{"name":"j","type":"uint256"}],"name":"foo","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"i","type":"uint256"}],"name":"foo","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"i","type":"uint256"}],"name":"bar","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"i","type":"uint256"},{"indexed":false,"name":"j","type":"uint256"}],"name":"bar","type":"event"}]`},
+ `
+ "math/big"
+ "time"
+
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/crypto"
+ `,
+ `
+ // Initialize test accounts
+ key, _ := crypto.GenerateKey()
+ auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
+ sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
+ defer sim.Close()
+
+ // deploy the test contract
+ _, _, contract, err := DeployOverload(auth, sim)
+ if err != nil {
+ t.Fatalf("Failed to deploy contract: %v", err)
+ }
+ // Finish deploy.
+ sim.Commit()
+
+ resCh, stopCh := make(chan uint64), make(chan struct{})
+
+ go func() {
+ barSink := make(chan *OverloadBar)
+ sub, _ := contract.WatchBar(nil, barSink)
+ defer sub.Unsubscribe()
+
+ bar0Sink := make(chan *OverloadBar0)
+ sub0, _ := contract.WatchBar0(nil, bar0Sink)
+ defer sub0.Unsubscribe()
+
+ for {
+ select {
+ case ev := <-barSink:
+ resCh <- ev.I.Uint64()
+ case ev := <-bar0Sink:
+ resCh <- ev.I.Uint64() + ev.J.Uint64()
+ case <-stopCh:
+ return
+ }
+ }
+ }()
+ contract.Foo(auth, big.NewInt(1), big.NewInt(2))
+ sim.Commit()
+ select {
+ case n := <-resCh:
+ if n != 3 {
+ t.Fatalf("Invalid bar0 event")
+ }
+ case <-time.NewTimer(3 * time.Second).C:
+ t.Fatalf("Wait bar0 event timeout")
+ }
+
+ contract.Foo0(auth, big.NewInt(1))
+ sim.Commit()
+ select {
+ case n := <-resCh:
+ if n != 1 {
+ t.Fatalf("Invalid bar event")
+ }
+ case <-time.NewTimer(3 * time.Second).C:
+ t.Fatalf("Wait bar event timeout")
+ }
+ close(stopCh)
+ `,
+ nil,
+ nil,
+ nil,
+ nil,
+ },
+ {
+ "IdentifierCollision",
+ `
+ pragma solidity >=0.4.19 <0.6.0;
+
+ contract IdentifierCollision {
+ uint public _myVar;
+
+ function MyVar() public view returns (uint) {
+ return _myVar;
+ }
+ }
+ `,
+ []string{"60806040523480156100115760006000fd5b50610017565b60c3806100256000396000f3fe608060405234801560105760006000fd5b506004361060365760003560e01c806301ad4d8714603c5780634ef1f0ad146058576036565b60006000fd5b60426074565b6040518082815260200191505060405180910390f35b605e607d565b6040518082815260200191505060405180910390f35b60006000505481565b60006000600050549050608b565b9056fea265627a7a7231582067c8d84688b01c4754ba40a2a871cede94ea1f28b5981593ab2a45b46ac43af664736f6c634300050c0032"},
+ []string{`[{"constant":true,"inputs":[],"name":"MyVar","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"_myVar","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"}]`},
+ `
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+ "github.com/ethereum/go-ethereum/crypto"
+ "github.com/ethereum/go-ethereum/core"
+ `,
+ `
+ // Initialize test accounts
+ key, _ := crypto.GenerateKey()
+ addr := crypto.PubkeyToAddress(key.PublicKey)
+
+ // Deploy registrar contract
+ sim := backends.NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(10000000000000000)}}, 10000000)
+ defer sim.Close()
+
+ transactOpts, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
+ _, _, _, err := DeployIdentifierCollision(transactOpts, sim)
+ if err != nil {
+ t.Fatalf("failed to deploy contract: %v", err)
+ }
+ `,
+ nil,
+ nil,
+ map[string]string{"_myVar": "pubVar"}, // alias MyVar to PubVar
+ nil,
+ },
+ {
+ "MultiContracts",
+ `
+ pragma solidity ^0.5.11;
+ pragma experimental ABIEncoderV2;
+
+ library ExternalLib {
+ struct SharedStruct{
+ uint256 f1;
+ bytes32 f2;
+ }
+ }
+
+ contract ContractOne {
+ function foo(ExternalLib.SharedStruct memory s) pure public {
+ // Do stuff
+ }
+ }
+
+ contract ContractTwo {
+ function bar(ExternalLib.SharedStruct memory s) pure public {
+ // Do stuff
+ }
+ }
+ `,
+ []string{
+ `60806040523480156100115760006000fd5b50610017565b6101b5806100266000396000f3fe60806040523480156100115760006000fd5b50600436106100305760003560e01c80639d8a8ba81461003657610030565b60006000fd5b610050600480360361004b91908101906100d1565b610052565b005b5b5056610171565b6000813590506100698161013d565b92915050565b6000604082840312156100825760006000fd5b61008c60406100fb565b9050600061009c848285016100bc565b60008301525060206100b08482850161005a565b60208301525092915050565b6000813590506100cb81610157565b92915050565b6000604082840312156100e45760006000fd5b60006100f28482850161006f565b91505092915050565b6000604051905081810181811067ffffffffffffffff8211171561011f5760006000fd5b8060405250919050565b6000819050919050565b6000819050919050565b61014681610129565b811415156101545760006000fd5b50565b61016081610133565b8114151561016e5760006000fd5b50565bfea365627a7a72315820749274eb7f6c01010d5322af4e1668b0a154409eb7968bd6cae5524c7ed669bb6c6578706572696d656e74616cf564736f6c634300050c0040`,
+ `60806040523480156100115760006000fd5b50610017565b6101b5806100266000396000f3fe60806040523480156100115760006000fd5b50600436106100305760003560e01c8063db8ba08c1461003657610030565b60006000fd5b610050600480360361004b91908101906100d1565b610052565b005b5b5056610171565b6000813590506100698161013d565b92915050565b6000604082840312156100825760006000fd5b61008c60406100fb565b9050600061009c848285016100bc565b60008301525060206100b08482850161005a565b60208301525092915050565b6000813590506100cb81610157565b92915050565b6000604082840312156100e45760006000fd5b60006100f28482850161006f565b91505092915050565b6000604051905081810181811067ffffffffffffffff8211171561011f5760006000fd5b8060405250919050565b6000819050919050565b6000819050919050565b61014681610129565b811415156101545760006000fd5b50565b61016081610133565b8114151561016e5760006000fd5b50565bfea365627a7a723158209bc28ee7ea97c131a13330d77ec73b4493b5c59c648352da81dd288b021192596c6578706572696d656e74616cf564736f6c634300050c0040`,
+ `606c6026600b82828239805160001a6073141515601857fe5b30600052607381538281f350fe73000000000000000000000000000000000000000030146080604052600436106023575b60006000fdfea365627a7a72315820518f0110144f5b3de95697d05e456a064656890d08e6f9cff47f3be710cc46a36c6578706572696d656e74616cf564736f6c634300050c0040`,
+ },
+ []string{
+ `[{"constant":true,"inputs":[{"components":[{"internalType":"uint256","name":"f1","type":"uint256"},{"internalType":"bytes32","name":"f2","type":"bytes32"}],"internalType":"struct ExternalLib.SharedStruct","name":"s","type":"tuple"}],"name":"foo","outputs":[],"payable":false,"stateMutability":"pure","type":"function"}]`,
+ `[{"constant":true,"inputs":[{"components":[{"internalType":"uint256","name":"f1","type":"uint256"},{"internalType":"bytes32","name":"f2","type":"bytes32"}],"internalType":"struct ExternalLib.SharedStruct","name":"s","type":"tuple"}],"name":"bar","outputs":[],"payable":false,"stateMutability":"pure","type":"function"}]`,
+ `[]`,
+ },
+ `
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+ "github.com/ethereum/go-ethereum/crypto"
+ "github.com/ethereum/go-ethereum/core"
+ `,
+ `
+ key, _ := crypto.GenerateKey()
+ addr := crypto.PubkeyToAddress(key.PublicKey)
+
+ // Deploy registrar contract
+ sim := backends.NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(10000000000000000)}}, 10000000)
+ defer sim.Close()
+
+ transactOpts, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
+ _, _, c1, err := DeployContractOne(transactOpts, sim)
+ if err != nil {
+ t.Fatal("Failed to deploy contract")
+ }
+ sim.Commit()
+ err = c1.Foo(nil, ExternalLibSharedStruct{
+ F1: big.NewInt(100),
+ F2: [32]byte{0x01, 0x02, 0x03},
+ })
+ if err != nil {
+ t.Fatal("Failed to invoke function")
+ }
+ _, _, c2, err := DeployContractTwo(transactOpts, sim)
+ if err != nil {
+ t.Fatal("Failed to deploy contract")
+ }
+ sim.Commit()
+ err = c2.Bar(nil, ExternalLibSharedStruct{
+ F1: big.NewInt(100),
+ F2: [32]byte{0x01, 0x02, 0x03},
+ })
+ if err != nil {
+ t.Fatal("Failed to invoke function")
+ }
+ `,
+ nil,
+ nil,
+ nil,
+ []string{"ContractOne", "ContractTwo", "ExternalLib"},
+ },
+ // Test the existence of the free retrieval calls
+ {
+ `PureAndView`,
+ `pragma solidity >=0.6.0;
+ contract PureAndView {
+ function PureFunc() public pure returns (uint) {
+ return 42;
+ }
+ function ViewFunc() public view returns (uint) {
+ return block.number;
+ }
+ }
+ `,
+ []string{`608060405234801561001057600080fd5b5060b68061001f6000396000f3fe6080604052348015600f57600080fd5b506004361060325760003560e01c806376b5686a146037578063bb38c66c146053575b600080fd5b603d606f565b6040518082815260200191505060405180910390f35b60596077565b6040518082815260200191505060405180910390f35b600043905090565b6000602a90509056fea2646970667358221220d158c2ab7fdfce366a7998ec79ab84edd43b9815630bbaede2c760ea77f29f7f64736f6c63430006000033`},
+ []string{`[{"inputs": [],"name": "PureFunc","outputs": [{"internalType": "uint256","name": "","type": "uint256"}],"stateMutability": "pure","type": "function"},{"inputs": [],"name": "ViewFunc","outputs": [{"internalType": "uint256","name": "","type": "uint256"}],"stateMutability": "view","type": "function"}]`},
+ `
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/crypto"
+ `,
+ `
+ // Generate a new random account and a funded simulator
+ key, _ := crypto.GenerateKey()
+ auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
+
+ sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
+ defer sim.Close()
+
+ // Deploy a tester contract and execute a structured call on it
+ _, _, pav, err := DeployPureAndView(auth, sim)
+ if err != nil {
+ t.Fatalf("Failed to deploy PureAndView contract: %v", err)
+ }
+ sim.Commit()
+
+ // This test the existence of the free retreiver call for view and pure functions
+ if num, err := pav.PureFunc(nil); err != nil {
+ t.Fatalf("Failed to call anonymous field retriever: %v", err)
+ } else if num.Cmp(big.NewInt(42)) != 0 {
+ t.Fatalf("Retrieved value mismatch: have %v, want %v", num, 42)
+ }
+ if num, err := pav.ViewFunc(nil); err != nil {
+ t.Fatalf("Failed to call anonymous field retriever: %v", err)
+ } else if num.Cmp(big.NewInt(1)) != 0 {
+ t.Fatalf("Retrieved value mismatch: have %v, want %v", num, 1)
+ }
+ `,
+ nil,
+ nil,
+ nil,
+ nil,
+ },
+ // Test fallback separation introduced in v0.6.0
+ {
+ `NewFallbacks`,
+ `
+ pragma solidity >=0.6.0 <0.7.0;
+
+ contract NewFallbacks {
+ event Fallback(bytes data);
+ fallback() external {
+ emit Fallback(msg.data);
+ }
+
+ event Received(address addr, uint value);
+ receive() external payable {
+ emit Received(msg.sender, msg.value);
+ }
+ }
+ `,
+ []string{"6080604052348015600f57600080fd5b506101078061001f6000396000f3fe608060405236605f577f88a5966d370b9919b20f3e2c13ff65706f196a4e32cc2c12bf57088f885258743334604051808373ffffffffffffffffffffffffffffffffffffffff1681526020018281526020019250505060405180910390a1005b348015606a57600080fd5b507f9043988963722edecc2099c75b0af0ff76af14ffca42ed6bce059a20a2a9f98660003660405180806020018281038252848482818152602001925080828437600081840152601f19601f820116905080830192505050935050505060405180910390a100fea26469706673582212201f994dcfbc53bf610b19176f9a361eafa77b447fd9c796fa2c615dfd0aaf3b8b64736f6c634300060c0033"},
+ []string{`[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"}],"name":"Fallback","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"addr","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Received","type":"event"},{"stateMutability":"nonpayable","type":"fallback"},{"stateMutability":"payable","type":"receive"}]`},
+ `
+ "bytes"
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/crypto"
+ `,
+ `
+ key, _ := crypto.GenerateKey()
+ addr := crypto.PubkeyToAddress(key.PublicKey)
+
+ sim := backends.NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(10000000000000000)}}, 1000000)
+ defer sim.Close()
+
+ opts, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
+ _, _, c, err := DeployNewFallbacks(opts, sim)
+ if err != nil {
+ t.Fatalf("Failed to deploy contract: %v", err)
+ }
+ sim.Commit()
+
+ // Test receive function
+ opts.Value = big.NewInt(100)
+ c.Receive(opts)
+ sim.Commit()
+
+ var gotEvent bool
+ iter, _ := c.FilterReceived(nil)
+ defer iter.Close()
+ for iter.Next() {
+ if iter.Event.Addr != addr {
+ t.Fatal("Msg.sender mismatch")
+ }
+ if iter.Event.Value.Uint64() != 100 {
+ t.Fatal("Msg.value mismatch")
+ }
+ gotEvent = true
+ break
+ }
+ if !gotEvent {
+ t.Fatal("Expect to receive event emitted by receive")
+ }
+
+ // Test fallback function
+ gotEvent = false
+ opts.Value = nil
+ calldata := []byte{0x01, 0x02, 0x03}
+ c.Fallback(opts, calldata)
+ sim.Commit()
+
+ iter2, _ := c.FilterFallback(nil)
+ defer iter2.Close()
+ for iter2.Next() {
+ if !bytes.Equal(iter2.Event.Data, calldata) {
+ t.Fatal("calldata mismatch")
+ }
+ gotEvent = true
+ break
+ }
+ if !gotEvent {
+ t.Fatal("Expect to receive event emitted by fallback")
+ }
+ `,
+ nil,
+ nil,
+ nil,
+ nil,
+ },
+ // Test resolving single struct argument
+ {
+ `NewSingleStructArgument`,
+ `
+ pragma solidity ^0.8.0;
+
+ contract NewSingleStructArgument {
+ struct MyStruct{
+ uint256 a;
+ uint256 b;
+ }
+ event StructEvent(MyStruct s);
+ function TestEvent() public {
+ emit StructEvent(MyStruct({a: 1, b: 2}));
+ }
+ }
+ `,
+ []string{"608060405234801561001057600080fd5b50610113806100206000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c806324ec1d3f14602d575b600080fd5b60336035565b005b7fb4b2ff75e30cb4317eaae16dd8a187dd89978df17565104caa6c2797caae27d460405180604001604052806001815260200160028152506040516078919060ba565b60405180910390a1565b6040820160008201516096600085018260ad565b50602082015160a7602085018260ad565b50505050565b60b48160d3565b82525050565b600060408201905060cd60008301846082565b92915050565b600081905091905056fea26469706673582212208823628796125bf9941ce4eda18da1be3cf2931b231708ab848e1bd7151c0c9a64736f6c63430008070033"},
+ []string{`[{"anonymous":false,"inputs":[{"components":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256","name":"b","type":"uint256"}],"indexed":false,"internalType":"struct Test.MyStruct","name":"s","type":"tuple"}],"name":"StructEvent","type":"event"},{"inputs":[],"name":"TestEvent","outputs":[],"stateMutability":"nonpayable","type":"function"}]`},
+ `
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/crypto"
+ "github.com/ethereum/go-ethereum/eth/ethconfig"
+ `,
+ `
+ var (
+ key, _ = crypto.GenerateKey()
+ user, _ = bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
+ sim = backends.NewSimulatedBackend(core.GenesisAlloc{user.From: {Balance: big.NewInt(1000000000000000000)}}, ethconfig.Defaults.Miner.GasCeil)
+ )
+ defer sim.Close()
+
+ _, _, d, err := DeployNewSingleStructArgument(user, sim)
+ if err != nil {
+ t.Fatalf("Failed to deploy contract %v", err)
+ }
+ sim.Commit()
+
+ _, err = d.TestEvent(user)
+ if err != nil {
+ t.Fatalf("Failed to call contract %v", err)
+ }
+ sim.Commit()
+
+ it, err := d.FilterStructEvent(nil)
+ if err != nil {
+ t.Fatalf("Failed to filter contract event %v", err)
+ }
+ var count int
+ for it.Next() {
+ if it.Event.S.A.Cmp(big.NewInt(1)) != 0 {
+ t.Fatal("Unexpected contract event")
+ }
+ if it.Event.S.B.Cmp(big.NewInt(2)) != 0 {
+ t.Fatal("Unexpected contract event")
+ }
+ count += 1
+ }
+ if count != 1 {
+ t.Fatal("Unexpected contract event number")
+ }
+ `,
+ nil,
+ nil,
+ nil,
+ nil,
+ },
+ // Test errors introduced in v0.8.4
+ {
+ `NewErrors`,
+ `
+ pragma solidity >0.8.4;
+
+ contract NewErrors {
+ error MyError(uint256);
+ error MyError1(uint256);
+ error MyError2(uint256, uint256);
+ error MyError3(uint256 a, uint256 b, uint256 c);
+ function Error() public pure {
+ revert MyError3(1,2,3);
+ }
+ }
+ `,
+ []string{"0x6080604052348015600f57600080fd5b5060998061001e6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063726c638214602d575b600080fd5b60336035565b005b60405163024876cd60e61b815260016004820152600260248201526003604482015260640160405180910390fdfea264697066735822122093f786a1bc60216540cd999fbb4a6109e0fef20abcff6e9107fb2817ca968f3c64736f6c63430008070033"},
+ []string{`[{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"MyError","type":"error"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"MyError1","type":"error"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"MyError2","type":"error"},{"inputs":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256","name":"b","type":"uint256"},{"internalType":"uint256","name":"c","type":"uint256"}],"name":"MyError3","type":"error"},{"inputs":[],"name":"Error","outputs":[],"stateMutability":"pure","type":"function"}]`},
+ `
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/crypto"
+ "github.com/ethereum/go-ethereum/eth/ethconfig"
+ `,
+ `
+ var (
+ key, _ = crypto.GenerateKey()
+ user, _ = bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
+ sim = backends.NewSimulatedBackend(core.GenesisAlloc{user.From: {Balance: big.NewInt(1000000000000000000)}}, ethconfig.Defaults.Miner.GasCeil)
+ )
+ defer sim.Close()
+
+ _, tx, contract, err := DeployNewErrors(user, sim)
+ if err != nil {
+ t.Fatal(err)
+ }
+ sim.Commit()
+ _, err = bind.WaitDeployed(nil, sim, tx)
+ if err != nil {
+ t.Error(err)
+ }
+ if err := contract.Error(new(bind.CallOpts)); err == nil {
+ t.Fatalf("expected contract to throw error")
+ }
+ // TODO (MariusVanDerWijden unpack error using abigen
+ // once that is implemented
+ `,
+ nil,
+ nil,
+ nil,
+ nil,
+ },
+ {
+ name: `ConstructorWithStructParam`,
+ contract: `
+ pragma solidity >=0.8.0 <0.9.0;
+
+ contract ConstructorWithStructParam {
+ struct StructType {
+ uint256 field;
+ }
+
+ constructor(StructType memory st) {}
+ }
+ `,
+ bytecode: []string{`0x608060405234801561001057600080fd5b506040516101c43803806101c48339818101604052810190610032919061014a565b50610177565b6000604051905090565b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6100958261004c565b810181811067ffffffffffffffff821117156100b4576100b361005d565b5b80604052505050565b60006100c7610038565b90506100d3828261008c565b919050565b6000819050919050565b6100eb816100d8565b81146100f657600080fd5b50565b600081519050610108816100e2565b92915050565b60006020828403121561012457610123610047565b5b61012e60206100bd565b9050600061013e848285016100f9565b60008301525092915050565b6000602082840312156101605761015f610042565b5b600061016e8482850161010e565b91505092915050565b603f806101856000396000f3fe6080604052600080fdfea2646970667358221220cdffa667affecefac5561f65f4a4ba914204a8d4eb859d8cd426fb306e5c12a364736f6c634300080a0033`},
+ abi: []string{`[{"inputs":[{"components":[{"internalType":"uint256","name":"field","type":"uint256"}],"internalType":"struct ConstructorWithStructParam.StructType","name":"st","type":"tuple"}],"stateMutability":"nonpayable","type":"constructor"}]`},
+ imports: `
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/crypto"
+ "github.com/ethereum/go-ethereum/eth/ethconfig"
+ `,
+ tester: `
+ var (
+ key, _ = crypto.GenerateKey()
+ user, _ = bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
+ sim = backends.NewSimulatedBackend(core.GenesisAlloc{user.From: {Balance: big.NewInt(1000000000000000000)}}, ethconfig.Defaults.Miner.GasCeil)
+ )
+ defer sim.Close()
+
+ _, tx, _, err := DeployConstructorWithStructParam(user, sim, ConstructorWithStructParamStructType{Field: big.NewInt(42)})
+ if err != nil {
+ t.Fatalf("DeployConstructorWithStructParam() got err %v; want nil err", err)
+ }
+ sim.Commit()
+
+ if _, err = bind.WaitDeployed(nil, sim, tx); err != nil {
+ t.Logf("Deployment tx: %+v", tx)
+ t.Errorf("bind.WaitDeployed(nil, %T, ) got err %v; want nil err", sim, err)
+ }
+ `,
+ },
+ {
+ name: `NameConflict`,
+ contract: `
+ // SPDX-License-Identifier: GPL-3.0
+ pragma solidity >=0.4.22 <0.9.0;
+ contract oracle {
+ struct request {
+ bytes data;
+ bytes _data;
+ }
+ event log (int msg, int _msg);
+ function addRequest(request memory req) public pure {}
+ function getRequest() pure public returns (request memory) {
+ return request("", "");
+ }
+ }
+ `,
+ bytecode: []string{`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`},
+ abi: []string{`[ { "anonymous": false, "inputs": [ { "indexed": false, "internalType": "int256", "name": "msg", "type": "int256" }, { "indexed": false, "internalType": "int256", "name": "_msg", "type": "int256" } ], "name": "log", "type": "event" }, { "inputs": [ { "components": [ { "internalType": "bytes", "name": "data", "type": "bytes" }, { "internalType": "bytes", "name": "_data", "type": "bytes" } ], "internalType": "struct oracle.request", "name": "req", "type": "tuple" } ], "name": "addRequest", "outputs": [], "stateMutability": "pure", "type": "function" }, { "inputs": [], "name": "getRequest", "outputs": [ { "components": [ { "internalType": "bytes", "name": "data", "type": "bytes" }, { "internalType": "bytes", "name": "_data", "type": "bytes" } ], "internalType": "struct oracle.request", "name": "", "type": "tuple" } ], "stateMutability": "pure", "type": "function" } ]`},
+ imports: `
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/crypto"
+ "github.com/ethereum/go-ethereum/eth/ethconfig"
+ `,
+ tester: `
+ var (
+ key, _ = crypto.GenerateKey()
+ user, _ = bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
+ sim = backends.NewSimulatedBackend(core.GenesisAlloc{user.From: {Balance: big.NewInt(1000000000000000000)}}, ethconfig.Defaults.Miner.GasCeil)
+ )
+ defer sim.Close()
+
+ _, tx, _, err := DeployNameConflict(user, sim)
+ if err != nil {
+ t.Fatalf("DeployNameConflict() got err %v; want nil err", err)
+ }
+ sim.Commit()
+
+ if _, err = bind.WaitDeployed(nil, sim, tx); err != nil {
+ t.Logf("Deployment tx: %+v", tx)
+ t.Errorf("bind.WaitDeployed(nil, %T, ) got err %v; want nil err", sim, err)
+ }
+ `,
+ },
+}
+
+// Tests that packages generated by the binder can be successfully compiled and
+// the requested tester run against it.
+func TestGolangBindings(t *testing.T) {
+ // Skip the test if no Go command can be found
+ gocmd := runtime.GOROOT() + "/bin/go"
+ if !common.FileExist(gocmd) {
+ t.Skip("go sdk not found for testing")
+ }
+ // Create a temporary workspace for the test suite
+ ws := t.TempDir()
+
+ pkg := filepath.Join(ws, "bindtest")
+ if err := os.MkdirAll(pkg, 0700); err != nil {
+ t.Fatalf("failed to create package: %v", err)
+ }
+ // Generate the test suite for all the contracts
+ for i, tt := range bindTests {
+ t.Run(tt.name, func(t *testing.T) {
+ var types []string
+ if tt.types != nil {
+ types = tt.types
+ } else {
+ types = []string{tt.name}
+ }
+ // Generate the binding and create a Go source file in the workspace
+ bind, err := Bind(types, tt.abi, tt.bytecode, tt.fsigs, "bindtest", LangGo, tt.libs, tt.aliases)
+ if err != nil {
+ t.Fatalf("test %d: failed to generate binding: %v", i, err)
+ }
+ if err = os.WriteFile(filepath.Join(pkg, strings.ToLower(tt.name)+".go"), []byte(bind), 0600); err != nil {
+ t.Fatalf("test %d: failed to write binding: %v", i, err)
+ }
+ // Generate the test file with the injected test code
+ code := fmt.Sprintf(`
+ package bindtest
+
+ import (
+ "testing"
+ %s
+ )
+
+ func Test%s(t *testing.T) {
+ %s
+ }
+ `, tt.imports, tt.name, tt.tester)
+ if err := os.WriteFile(filepath.Join(pkg, strings.ToLower(tt.name)+"_test.go"), []byte(code), 0600); err != nil {
+ t.Fatalf("test %d: failed to write tests: %v", i, err)
+ }
+ })
+ }
+ // Convert the package to go modules and use the current source for go-ethereum
+ moder := exec.Command(gocmd, "mod", "init", "bindtest")
+ moder.Dir = pkg
+ if out, err := moder.CombinedOutput(); err != nil {
+ t.Fatalf("failed to convert binding test to modules: %v\n%s", err, out)
+ }
+ pwd, _ := os.Getwd()
+ replacer := exec.Command(gocmd, "mod", "edit", "-x", "-require", "github.com/ethereum/go-ethereum@v0.0.0", "-replace", "github.com/ethereum/go-ethereum="+filepath.Join(pwd, "..", "..", "..")) // Repo root
+ replacer.Dir = pkg
+ if out, err := replacer.CombinedOutput(); err != nil {
+ t.Fatalf("failed to replace binding test dependency to current source tree: %v\n%s", err, out)
+ }
+ tidier := exec.Command(gocmd, "mod", "tidy")
+ tidier.Dir = pkg
+ if out, err := tidier.CombinedOutput(); err != nil {
+ t.Fatalf("failed to tidy Go module file: %v\n%s", err, out)
+ }
+ // Test the entire package and report any failures
+ cmd := exec.Command(gocmd, "test", "-v", "-count", "1")
+ cmd.Dir = pkg
+ if out, err := cmd.CombinedOutput(); err != nil {
+ t.Fatalf("failed to run binding test: %v\n%s", err, out)
+ }
+}
+
+// Tests that java binding generated by the binder is exactly matched.
+func TestJavaBindings(t *testing.T) {
+ var cases = []struct {
+ name string
+ contract string
+ abi string
+ bytecode string
+ expected string
+ }{
+ {
+ "test",
+ `
+ pragma experimental ABIEncoderV2;
+ pragma solidity ^0.5.2;
+
+ contract test {
+ function setAddress(address a) public returns(address){}
+ function setAddressList(address[] memory a_l) public returns(address[] memory){}
+ function setAddressArray(address[2] memory a_a) public returns(address[2] memory){}
+
+ function setUint8(uint8 u8) public returns(uint8){}
+ function setUint16(uint16 u16) public returns(uint16){}
+ function setUint32(uint32 u32) public returns(uint32){}
+ function setUint64(uint64 u64) public returns(uint64){}
+ function setUint256(uint256 u256) public returns(uint256){}
+ function setUint256List(uint256[] memory u256_l) public returns(uint256[] memory){}
+ function setUint256Array(uint256[2] memory u256_a) public returns(uint256[2] memory){}
+
+ function setInt8(int8 i8) public returns(int8){}
+ function setInt16(int16 i16) public returns(int16){}
+ function setInt32(int32 i32) public returns(int32){}
+ function setInt64(int64 i64) public returns(int64){}
+ function setInt256(int256 i256) public returns(int256){}
+ function setInt256List(int256[] memory i256_l) public returns(int256[] memory){}
+ function setInt256Array(int256[2] memory i256_a) public returns(int256[2] memory){}
+
+ function setBytes1(bytes1 b1) public returns(bytes1) {}
+ function setBytes32(bytes32 b32) public returns(bytes32) {}
+ function setBytes(bytes memory bs) public returns(bytes memory) {}
+ function setBytesList(bytes[] memory bs_l) public returns(bytes[] memory) {}
+ function setBytesArray(bytes[2] memory bs_a) public returns(bytes[2] memory) {}
+
+ function setString(string memory s) public returns(string memory) {}
+ function setStringList(string[] memory s_l) public returns(string[] memory) {}
+ function setStringArray(string[2] memory s_a) public returns(string[2] memory) {}
+
+ function setBool(bool b) public returns(bool) {}
+ function setBoolList(bool[] memory b_l) public returns(bool[] memory) {}
+ function setBoolArray(bool[2] memory b_a) public returns(bool[2] memory) {}
+ }`,
+ `[{"constant":false,"inputs":[{"name":"u16","type":"uint16"}],"name":"setUint16","outputs":[{"name":"","type":"uint16"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"b_a","type":"bool[2]"}],"name":"setBoolArray","outputs":[{"name":"","type":"bool[2]"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"a_a","type":"address[2]"}],"name":"setAddressArray","outputs":[{"name":"","type":"address[2]"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"bs_l","type":"bytes[]"}],"name":"setBytesList","outputs":[{"name":"","type":"bytes[]"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"u8","type":"uint8"}],"name":"setUint8","outputs":[{"name":"","type":"uint8"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"u32","type":"uint32"}],"name":"setUint32","outputs":[{"name":"","type":"uint32"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"b","type":"bool"}],"name":"setBool","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"i256_l","type":"int256[]"}],"name":"setInt256List","outputs":[{"name":"","type":"int256[]"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"u256_a","type":"uint256[2]"}],"name":"setUint256Array","outputs":[{"name":"","type":"uint256[2]"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"b_l","type":"bool[]"}],"name":"setBoolList","outputs":[{"name":"","type":"bool[]"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"bs_a","type":"bytes[2]"}],"name":"setBytesArray","outputs":[{"name":"","type":"bytes[2]"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"a_l","type":"address[]"}],"name":"setAddressList","outputs":[{"name":"","type":"address[]"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"i256_a","type":"int256[2]"}],"name":"setInt256Array","outputs":[{"name":"","type":"int256[2]"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"s_a","type":"string[2]"}],"name":"setStringArray","outputs":[{"name":"","type":"string[2]"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"s","type":"string"}],"name":"setString","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"u64","type":"uint64"}],"name":"setUint64","outputs":[{"name":"","type":"uint64"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"i16","type":"int16"}],"name":"setInt16","outputs":[{"name":"","type":"int16"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"i8","type":"int8"}],"name":"setInt8","outputs":[{"name":"","type":"int8"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"u256_l","type":"uint256[]"}],"name":"setUint256List","outputs":[{"name":"","type":"uint256[]"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"i256","type":"int256"}],"name":"setInt256","outputs":[{"name":"","type":"int256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"i32","type":"int32"}],"name":"setInt32","outputs":[{"name":"","type":"int32"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"b32","type":"bytes32"}],"name":"setBytes32","outputs":[{"name":"","type":"bytes32"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"s_l","type":"string[]"}],"name":"setStringList","outputs":[{"name":"","type":"string[]"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"u256","type":"uint256"}],"name":"setUint256","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"bs","type":"bytes"}],"name":"setBytes","outputs":[{"name":"","type":"bytes"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"a","type":"address"}],"name":"setAddress","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"i64","type":"int64"}],"name":"setInt64","outputs":[{"name":"","type":"int64"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"b1","type":"bytes1"}],"name":"setBytes1","outputs":[{"name":"","type":"bytes1"}],"payable":false,"stateMutability":"nonpayable","type":"function"}]`,
+ `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`,
+ `
+// This file is an automatically generated Java binding. Do not modify as any
+// change will likely be lost upon the next re-generation!
+
+package bindtest;
+
+import org.ethereum.geth.*;
+import java.util.*;
+
+public class Test {
+ // ABI is the input ABI used to generate the binding from.
+ public final static String ABI = "[{\"constant\":false,\"inputs\":[{\"name\":\"u16\",\"type\":\"uint16\"}],\"name\":\"setUint16\",\"outputs\":[{\"name\":\"\",\"type\":\"uint16\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"b_a\",\"type\":\"bool[2]\"}],\"name\":\"setBoolArray\",\"outputs\":[{\"name\":\"\",\"type\":\"bool[2]\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"a_a\",\"type\":\"address[2]\"}],\"name\":\"setAddressArray\",\"outputs\":[{\"name\":\"\",\"type\":\"address[2]\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"bs_l\",\"type\":\"bytes[]\"}],\"name\":\"setBytesList\",\"outputs\":[{\"name\":\"\",\"type\":\"bytes[]\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"u8\",\"type\":\"uint8\"}],\"name\":\"setUint8\",\"outputs\":[{\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"u32\",\"type\":\"uint32\"}],\"name\":\"setUint32\",\"outputs\":[{\"name\":\"\",\"type\":\"uint32\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"b\",\"type\":\"bool\"}],\"name\":\"setBool\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"i256_l\",\"type\":\"int256[]\"}],\"name\":\"setInt256List\",\"outputs\":[{\"name\":\"\",\"type\":\"int256[]\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"u256_a\",\"type\":\"uint256[2]\"}],\"name\":\"setUint256Array\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256[2]\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"b_l\",\"type\":\"bool[]\"}],\"name\":\"setBoolList\",\"outputs\":[{\"name\":\"\",\"type\":\"bool[]\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"bs_a\",\"type\":\"bytes[2]\"}],\"name\":\"setBytesArray\",\"outputs\":[{\"name\":\"\",\"type\":\"bytes[2]\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"a_l\",\"type\":\"address[]\"}],\"name\":\"setAddressList\",\"outputs\":[{\"name\":\"\",\"type\":\"address[]\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"i256_a\",\"type\":\"int256[2]\"}],\"name\":\"setInt256Array\",\"outputs\":[{\"name\":\"\",\"type\":\"int256[2]\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"s_a\",\"type\":\"string[2]\"}],\"name\":\"setStringArray\",\"outputs\":[{\"name\":\"\",\"type\":\"string[2]\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"s\",\"type\":\"string\"}],\"name\":\"setString\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"u64\",\"type\":\"uint64\"}],\"name\":\"setUint64\",\"outputs\":[{\"name\":\"\",\"type\":\"uint64\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"i16\",\"type\":\"int16\"}],\"name\":\"setInt16\",\"outputs\":[{\"name\":\"\",\"type\":\"int16\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"i8\",\"type\":\"int8\"}],\"name\":\"setInt8\",\"outputs\":[{\"name\":\"\",\"type\":\"int8\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"u256_l\",\"type\":\"uint256[]\"}],\"name\":\"setUint256List\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256[]\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"i256\",\"type\":\"int256\"}],\"name\":\"setInt256\",\"outputs\":[{\"name\":\"\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"i32\",\"type\":\"int32\"}],\"name\":\"setInt32\",\"outputs\":[{\"name\":\"\",\"type\":\"int32\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"b32\",\"type\":\"bytes32\"}],\"name\":\"setBytes32\",\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"s_l\",\"type\":\"string[]\"}],\"name\":\"setStringList\",\"outputs\":[{\"name\":\"\",\"type\":\"string[]\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"u256\",\"type\":\"uint256\"}],\"name\":\"setUint256\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"bs\",\"type\":\"bytes\"}],\"name\":\"setBytes\",\"outputs\":[{\"name\":\"\",\"type\":\"bytes\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"a\",\"type\":\"address\"}],\"name\":\"setAddress\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"i64\",\"type\":\"int64\"}],\"name\":\"setInt64\",\"outputs\":[{\"name\":\"\",\"type\":\"int64\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"b1\",\"type\":\"bytes1\"}],\"name\":\"setBytes1\",\"outputs\":[{\"name\":\"\",\"type\":\"bytes1\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]";
+
+ // BYTECODE is the compiled bytecode used for deploying new contracts.
+ public final static String BYTECODE = "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";
+
+ // deploy deploys a new Ethereum contract, binding an instance of Test to it.
+ public static Test deploy(TransactOpts auth, EthereumClient client) throws Exception {
+ Interfaces args = Geth.newInterfaces(0);
+ String bytecode = BYTECODE;
+ return new Test(Geth.deployContract(auth, ABI, Geth.decodeFromHex(bytecode), client, args));
+ }
+
+ // Internal constructor used by contract deployment.
+ private Test(BoundContract deployment) {
+ this.Address = deployment.getAddress();
+ this.Deployer = deployment.getDeployer();
+ this.Contract = deployment;
+ }
+
+ // Ethereum address where this contract is located at.
+ public final Address Address;
+
+ // Ethereum transaction in which this contract was deployed (if known!).
+ public final Transaction Deployer;
+
+ // Contract instance bound to a blockchain address.
+ private final BoundContract Contract;
+
+ // Creates a new instance of Test, bound to a specific deployed contract.
+ public Test(Address address, EthereumClient client) throws Exception {
+ this(Geth.bindContract(address, ABI, client));
+ }
+
+ // setAddress is a paid mutator transaction binding the contract method 0xe30081a0.
+ //
+ // Solidity: function setAddress(address a) returns(address)
+ public Transaction setAddress(TransactOpts opts, Address a) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setAddress(a);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setAddress" , args);
+ }
+
+ // setAddressArray is a paid mutator transaction binding the contract method 0x151f5471.
+ //
+ // Solidity: function setAddressArray(address[2] a_a) returns(address[2])
+ public Transaction setAddressArray(TransactOpts opts, Addresses a_a) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setAddresses(a_a);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setAddressArray" , args);
+ }
+
+ // setAddressList is a paid mutator transaction binding the contract method 0x5be6b37e.
+ //
+ // Solidity: function setAddressList(address[] a_l) returns(address[])
+ public Transaction setAddressList(TransactOpts opts, Addresses a_l) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setAddresses(a_l);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setAddressList" , args);
+ }
+
+ // setBool is a paid mutator transaction binding the contract method 0x1e26fd33.
+ //
+ // Solidity: function setBool(bool b) returns(bool)
+ public Transaction setBool(TransactOpts opts, boolean b) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setBool(b);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setBool" , args);
+ }
+
+ // setBoolArray is a paid mutator transaction binding the contract method 0x118a9718.
+ //
+ // Solidity: function setBoolArray(bool[2] b_a) returns(bool[2])
+ public Transaction setBoolArray(TransactOpts opts, Bools b_a) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setBools(b_a);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setBoolArray" , args);
+ }
+
+ // setBoolList is a paid mutator transaction binding the contract method 0x4d5ee6da.
+ //
+ // Solidity: function setBoolList(bool[] b_l) returns(bool[])
+ public Transaction setBoolList(TransactOpts opts, Bools b_l) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setBools(b_l);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setBoolList" , args);
+ }
+
+ // setBytes is a paid mutator transaction binding the contract method 0xda359dc8.
+ //
+ // Solidity: function setBytes(bytes bs) returns(bytes)
+ public Transaction setBytes(TransactOpts opts, byte[] bs) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setBinary(bs);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setBytes" , args);
+ }
+
+ // setBytes1 is a paid mutator transaction binding the contract method 0xfba1a1c3.
+ //
+ // Solidity: function setBytes1(bytes1 b1) returns(bytes1)
+ public Transaction setBytes1(TransactOpts opts, byte[] b1) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setBinary(b1);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setBytes1" , args);
+ }
+
+ // setBytes32 is a paid mutator transaction binding the contract method 0xc2b12a73.
+ //
+ // Solidity: function setBytes32(bytes32 b32) returns(bytes32)
+ public Transaction setBytes32(TransactOpts opts, byte[] b32) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setBinary(b32);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setBytes32" , args);
+ }
+
+ // setBytesArray is a paid mutator transaction binding the contract method 0x5119655d.
+ //
+ // Solidity: function setBytesArray(bytes[2] bs_a) returns(bytes[2])
+ public Transaction setBytesArray(TransactOpts opts, Binaries bs_a) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setBinaries(bs_a);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setBytesArray" , args);
+ }
+
+ // setBytesList is a paid mutator transaction binding the contract method 0x16c105e2.
+ //
+ // Solidity: function setBytesList(bytes[] bs_l) returns(bytes[])
+ public Transaction setBytesList(TransactOpts opts, Binaries bs_l) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setBinaries(bs_l);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setBytesList" , args);
+ }
+
+ // setInt16 is a paid mutator transaction binding the contract method 0x86114cea.
+ //
+ // Solidity: function setInt16(int16 i16) returns(int16)
+ public Transaction setInt16(TransactOpts opts, short i16) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setInt16(i16);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setInt16" , args);
+ }
+
+ // setInt256 is a paid mutator transaction binding the contract method 0xa53b1c1e.
+ //
+ // Solidity: function setInt256(int256 i256) returns(int256)
+ public Transaction setInt256(TransactOpts opts, BigInt i256) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setBigInt(i256);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setInt256" , args);
+ }
+
+ // setInt256Array is a paid mutator transaction binding the contract method 0x6aa482fc.
+ //
+ // Solidity: function setInt256Array(int256[2] i256_a) returns(int256[2])
+ public Transaction setInt256Array(TransactOpts opts, BigInts i256_a) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setBigInts(i256_a);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setInt256Array" , args);
+ }
+
+ // setInt256List is a paid mutator transaction binding the contract method 0x22722302.
+ //
+ // Solidity: function setInt256List(int256[] i256_l) returns(int256[])
+ public Transaction setInt256List(TransactOpts opts, BigInts i256_l) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setBigInts(i256_l);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setInt256List" , args);
+ }
+
+ // setInt32 is a paid mutator transaction binding the contract method 0xb7d5df31.
+ //
+ // Solidity: function setInt32(int32 i32) returns(int32)
+ public Transaction setInt32(TransactOpts opts, int i32) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setInt32(i32);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setInt32" , args);
+ }
+
+ // setInt64 is a paid mutator transaction binding the contract method 0xe673eb32.
+ //
+ // Solidity: function setInt64(int64 i64) returns(int64)
+ public Transaction setInt64(TransactOpts opts, long i64) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setInt64(i64);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setInt64" , args);
+ }
+
+ // setInt8 is a paid mutator transaction binding the contract method 0x9a19a953.
+ //
+ // Solidity: function setInt8(int8 i8) returns(int8)
+ public Transaction setInt8(TransactOpts opts, byte i8) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setInt8(i8);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setInt8" , args);
+ }
+
+ // setString is a paid mutator transaction binding the contract method 0x7fcaf666.
+ //
+ // Solidity: function setString(string s) returns(string)
+ public Transaction setString(TransactOpts opts, String s) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setString(s);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setString" , args);
+ }
+
+ // setStringArray is a paid mutator transaction binding the contract method 0x7173b695.
+ //
+ // Solidity: function setStringArray(string[2] s_a) returns(string[2])
+ public Transaction setStringArray(TransactOpts opts, Strings s_a) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setStrings(s_a);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setStringArray" , args);
+ }
+
+ // setStringList is a paid mutator transaction binding the contract method 0xc5777961.
+ //
+ // Solidity: function setStringList(string[] s_l) returns(string[])
+ public Transaction setStringList(TransactOpts opts, Strings s_l) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setStrings(s_l);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setStringList" , args);
+ }
+
+ // setUint16 is a paid mutator transaction binding the contract method 0x0477988a.
+ //
+ // Solidity: function setUint16(uint16 u16) returns(uint16)
+ public Transaction setUint16(TransactOpts opts, BigInt u16) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setUint16(u16);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setUint16" , args);
+ }
+
+ // setUint256 is a paid mutator transaction binding the contract method 0xd2282dc5.
+ //
+ // Solidity: function setUint256(uint256 u256) returns(uint256)
+ public Transaction setUint256(TransactOpts opts, BigInt u256) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setBigInt(u256);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setUint256" , args);
+ }
+
+ // setUint256Array is a paid mutator transaction binding the contract method 0x2766a755.
+ //
+ // Solidity: function setUint256Array(uint256[2] u256_a) returns(uint256[2])
+ public Transaction setUint256Array(TransactOpts opts, BigInts u256_a) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setBigInts(u256_a);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setUint256Array" , args);
+ }
+
+ // setUint256List is a paid mutator transaction binding the contract method 0xa0709e19.
+ //
+ // Solidity: function setUint256List(uint256[] u256_l) returns(uint256[])
+ public Transaction setUint256List(TransactOpts opts, BigInts u256_l) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setBigInts(u256_l);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setUint256List" , args);
+ }
+
+ // setUint32 is a paid mutator transaction binding the contract method 0x1c9352e2.
+ //
+ // Solidity: function setUint32(uint32 u32) returns(uint32)
+ public Transaction setUint32(TransactOpts opts, BigInt u32) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setUint32(u32);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setUint32" , args);
+ }
+
+ // setUint64 is a paid mutator transaction binding the contract method 0x822cba69.
+ //
+ // Solidity: function setUint64(uint64 u64) returns(uint64)
+ public Transaction setUint64(TransactOpts opts, BigInt u64) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setUint64(u64);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setUint64" , args);
+ }
+
+ // setUint8 is a paid mutator transaction binding the contract method 0x1774e646.
+ //
+ // Solidity: function setUint8(uint8 u8) returns(uint8)
+ public Transaction setUint8(TransactOpts opts, BigInt u8) throws Exception {
+ Interfaces args = Geth.newInterfaces(1);
+ Interface arg0 = Geth.newInterface();arg0.setUint8(u8);args.set(0,arg0);
+
+ return this.Contract.transact(opts, "setUint8" , args);
+ }
+}
+`,
+ },
+ }
+ for i, c := range cases {
+ binding, err := Bind([]string{c.name}, []string{c.abi}, []string{c.bytecode}, nil, "bindtest", LangJava, nil, nil)
+ if err != nil {
+ t.Fatalf("test %d: failed to generate binding: %v", i, err)
+ }
+ // Remove empty lines
+ removeEmptys := func(input string) string {
+ lines := strings.Split(input, "\n")
+ var index int
+ for _, line := range lines {
+ if strings.TrimSpace(line) != "" {
+ lines[index] = line
+ index += 1
+ }
+ }
+ lines = lines[:index]
+ return strings.Join(lines, "\n")
+ }
+ binding = removeEmptys(binding)
+ expect := removeEmptys(c.expected)
+ if binding != expect {
+ t.Fatalf("test %d: generated binding mismatch, has %s, want %s", i, binding, c.expected)
+ }
+ }
+}
diff --git a/abigen/accounts/abi/bind/template.go b/abigen/accounts/abi/bind/template.go
new file mode 100644
index 00000000..3a99d194
--- /dev/null
+++ b/abigen/accounts/abi/bind/template.go
@@ -0,0 +1,708 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package bind
+
+import "gitlab.com/alphaticks/abigen-starknet/accounts/abi"
+
+// tmplData is the data structure required to fill the binding template.
+type tmplData struct {
+ Package string // Name of the package to place the generated file in
+ Contracts map[string]*tmplContract // List of contracts to generate into this file
+ Libraries map[string]string // Map the bytecode's link pattern to the library name
+ Structs map[string]*tmplStruct // Contract struct type definitions
+}
+
+// tmplContract contains the data needed to generate an individual contract binding.
+type tmplContract struct {
+ Type string // Type name of the main contract binding
+ InputABI string // JSON ABI used as the input to generate the binding from
+ InputBin string // Optional EVM bytecode used to generate deploy code from
+ FuncSigs map[string]string // Optional map: string signature -> 4-byte signature
+ Constructor abi.Method // Contract constructor for deploy parametrization
+ Calls map[string]*tmplMethod // Contract calls that only read state data
+ Transacts map[string]*tmplMethod // Contract calls that write state data
+ Fallback *tmplMethod // Additional special fallback function
+ Receive *tmplMethod // Additional special receive function
+ Events map[string]*tmplEvent // Contract events accessors
+ Libraries map[string]string // Same as tmplData, but filtered to only keep what the contract needs
+ Library bool // Indicator whether the contract is a library
+}
+
+// tmplMethod is a wrapper around an abi.Method that contains a few preprocessed
+// and cached data fields.
+type tmplMethod struct {
+ Original abi.Method // Original method as parsed by the abi package
+ Normalized abi.Method // Normalized version of the parsed method (capitalized names, non-anonymous args/returns)
+ Structured bool // Whether the returns should be accumulated into a struct
+}
+
+// tmplEvent is a wrapper around an abi.Event that contains a few preprocessed
+// and cached data fields.
+type tmplEvent struct {
+ Original abi.Event // Original event as parsed by the abi package
+ Normalized abi.Event // Normalized version of the parsed fields
+}
+
+// tmplField is a wrapper around a struct field with binding language
+// struct type definition and relative filed name.
+type tmplField struct {
+ Type string // Field type representation depends on target binding language
+ Name string // Field name converted from the raw user-defined field name
+ SolKind abi.Type // Raw abi type information
+}
+
+// tmplStruct is a wrapper around an abi.tuple and contains an auto-generated
+// struct name.
+type tmplStruct struct {
+ Name string // Auto-generated struct name(before solidity v0.5.11) or raw name.
+ Fields []*tmplField // Struct fields definition depends on the binding language.
+}
+
+// tmplSource is language to template mapping containing all the supported
+// programming languages the package can generate to.
+var tmplSource = map[Lang]string{
+ LangGo: tmplSourceGo,
+ LangJava: tmplSourceJava,
+}
+
+// tmplSourceGo is the Go source template that the generated Go contract binding
+// is based on.
+const tmplSourceGo = `
+// Code generated - DO NOT EDIT.
+// This file is a generated binding and any manual changes will be lost.
+
+package {{.Package}}
+
+import (
+ "math/big"
+ "strings"
+ "errors"
+
+ ethereum "github.com/ethereum/go-ethereum"
+ "github.com/ethereum/go-ethereum/accounts/abi"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/event"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var (
+ _ = errors.New
+ _ = big.NewInt
+ _ = strings.NewReader
+ _ = ethereum.NotFound
+ _ = bind.Bind
+ _ = common.Big1
+ _ = types.BloomLookup
+ _ = event.NewSubscription
+)
+
+{{$structs := .Structs}}
+{{range $structs}}
+ // {{.Name}} is an auto generated low-level Go binding around an user-defined struct.
+ type {{.Name}} struct {
+ {{range $field := .Fields}}
+ {{$field.Name}} {{$field.Type}}{{end}}
+ }
+{{end}}
+
+{{range $contract := .Contracts}}
+ // {{.Type}}MetaData contains all meta data concerning the {{.Type}} contract.
+ var {{.Type}}MetaData = &bind.MetaData{
+ ABI: "{{.InputABI}}",
+ {{if $contract.FuncSigs -}}
+ Sigs: map[string]string{
+ {{range $strsig, $binsig := .FuncSigs}}"{{$binsig}}": "{{$strsig}}",
+ {{end}}
+ },
+ {{end -}}
+ {{if .InputBin -}}
+ Bin: "0x{{.InputBin}}",
+ {{end}}
+ }
+ // {{.Type}}ABI is the input ABI used to generate the binding from.
+ // Deprecated: Use {{.Type}}MetaData.ABI instead.
+ var {{.Type}}ABI = {{.Type}}MetaData.ABI
+
+ {{if $contract.FuncSigs}}
+ // Deprecated: Use {{.Type}}MetaData.Sigs instead.
+ // {{.Type}}FuncSigs maps the 4-byte function signature to its string representation.
+ var {{.Type}}FuncSigs = {{.Type}}MetaData.Sigs
+ {{end}}
+
+ {{if .InputBin}}
+ // {{.Type}}Bin is the compiled bytecode used for deploying new contracts.
+ // Deprecated: Use {{.Type}}MetaData.Bin instead.
+ var {{.Type}}Bin = {{.Type}}MetaData.Bin
+
+ // Deploy{{.Type}} deploys a new Ethereum contract, binding an instance of {{.Type}} to it.
+ func Deploy{{.Type}}(auth *bind.TransactOpts, backend bind.ContractBackend {{range .Constructor.Inputs}}, {{.Name}} {{bindtype .Type $structs}}{{end}}) (common.Address, *types.Transaction, *{{.Type}}, error) {
+ parsed, err := {{.Type}}MetaData.GetAbi()
+ if err != nil {
+ return common.Address{}, nil, nil, err
+ }
+ if parsed == nil {
+ return common.Address{}, nil, nil, errors.New("GetABI returned nil")
+ }
+ {{range $pattern, $name := .Libraries}}
+ {{decapitalise $name}}Addr, _, _, _ := Deploy{{capitalise $name}}(auth, backend)
+ {{$contract.Type}}Bin = strings.ReplaceAll({{$contract.Type}}Bin, "__${{$pattern}}$__", {{decapitalise $name}}Addr.String()[2:])
+ {{end}}
+ address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex({{.Type}}Bin), backend {{range .Constructor.Inputs}}, {{.Name}}{{end}})
+ if err != nil {
+ return common.Address{}, nil, nil, err
+ }
+ return address, tx, &{{.Type}}{ {{.Type}}Caller: {{.Type}}Caller{contract: contract}, {{.Type}}Transactor: {{.Type}}Transactor{contract: contract}, {{.Type}}Filterer: {{.Type}}Filterer{contract: contract} }, nil
+ }
+ {{end}}
+
+ // {{.Type}} is an auto generated Go binding around an Ethereum contract.
+ type {{.Type}} struct {
+ {{.Type}}Caller // Read-only binding to the contract
+ {{.Type}}Transactor // Write-only binding to the contract
+ {{.Type}}Filterer // Log filterer for contract events
+ }
+
+ // {{.Type}}Caller is an auto generated read-only Go binding around an Ethereum contract.
+ type {{.Type}}Caller struct {
+ contract *bind.BoundContract // Generic contract wrapper for the low level calls
+ }
+
+ // {{.Type}}Transactor is an auto generated write-only Go binding around an Ethereum contract.
+ type {{.Type}}Transactor struct {
+ contract *bind.BoundContract // Generic contract wrapper for the low level calls
+ }
+
+ // {{.Type}}Filterer is an auto generated log filtering Go binding around an Ethereum contract events.
+ type {{.Type}}Filterer struct {
+ contract *bind.BoundContract // Generic contract wrapper for the low level calls
+ }
+
+ // {{.Type}}Session is an auto generated Go binding around an Ethereum contract,
+ // with pre-set call and transact options.
+ type {{.Type}}Session struct {
+ Contract *{{.Type}} // Generic contract binding to set the session for
+ CallOpts bind.CallOpts // Call options to use throughout this session
+ TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
+ }
+
+ // {{.Type}}CallerSession is an auto generated read-only Go binding around an Ethereum contract,
+ // with pre-set call options.
+ type {{.Type}}CallerSession struct {
+ Contract *{{.Type}}Caller // Generic contract caller binding to set the session for
+ CallOpts bind.CallOpts // Call options to use throughout this session
+ }
+
+ // {{.Type}}TransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+ // with pre-set transact options.
+ type {{.Type}}TransactorSession struct {
+ Contract *{{.Type}}Transactor // Generic contract transactor binding to set the session for
+ TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
+ }
+
+ // {{.Type}}Raw is an auto generated low-level Go binding around an Ethereum contract.
+ type {{.Type}}Raw struct {
+ Contract *{{.Type}} // Generic contract binding to access the raw methods on
+ }
+
+ // {{.Type}}CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+ type {{.Type}}CallerRaw struct {
+ Contract *{{.Type}}Caller // Generic read-only contract binding to access the raw methods on
+ }
+
+ // {{.Type}}TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+ type {{.Type}}TransactorRaw struct {
+ Contract *{{.Type}}Transactor // Generic write-only contract binding to access the raw methods on
+ }
+
+ // New{{.Type}} creates a new instance of {{.Type}}, bound to a specific deployed contract.
+ func New{{.Type}}(address common.Address, backend bind.ContractBackend) (*{{.Type}}, error) {
+ contract, err := bind{{.Type}}(address, backend, backend, backend)
+ if err != nil {
+ return nil, err
+ }
+ return &{{.Type}}{ {{.Type}}Caller: {{.Type}}Caller{contract: contract}, {{.Type}}Transactor: {{.Type}}Transactor{contract: contract}, {{.Type}}Filterer: {{.Type}}Filterer{contract: contract} }, nil
+ }
+
+ // New{{.Type}}Caller creates a new read-only instance of {{.Type}}, bound to a specific deployed contract.
+ func New{{.Type}}Caller(address common.Address, caller bind.ContractCaller) (*{{.Type}}Caller, error) {
+ contract, err := bind{{.Type}}(address, caller, nil, nil)
+ if err != nil {
+ return nil, err
+ }
+ return &{{.Type}}Caller{contract: contract}, nil
+ }
+
+ // New{{.Type}}Transactor creates a new write-only instance of {{.Type}}, bound to a specific deployed contract.
+ func New{{.Type}}Transactor(address common.Address, transactor bind.ContractTransactor) (*{{.Type}}Transactor, error) {
+ contract, err := bind{{.Type}}(address, nil, transactor, nil)
+ if err != nil {
+ return nil, err
+ }
+ return &{{.Type}}Transactor{contract: contract}, nil
+ }
+
+ // New{{.Type}}Filterer creates a new log filterer instance of {{.Type}}, bound to a specific deployed contract.
+ func New{{.Type}}Filterer(address common.Address, filterer bind.ContractFilterer) (*{{.Type}}Filterer, error) {
+ contract, err := bind{{.Type}}(address, nil, nil, filterer)
+ if err != nil {
+ return nil, err
+ }
+ return &{{.Type}}Filterer{contract: contract}, nil
+ }
+
+ // bind{{.Type}} binds a generic wrapper to an already deployed contract.
+ func bind{{.Type}}(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+ parsed, err := abi.JSON(strings.NewReader({{.Type}}ABI))
+ if err != nil {
+ return nil, err
+ }
+ return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
+ }
+
+ // Call invokes the (constant) contract method with params as input values and
+ // sets the output to result. The result type might be a single field for simple
+ // returns, a slice of interfaces for anonymous returns and a struct for named
+ // returns.
+ func (_{{$contract.Type}} *{{$contract.Type}}Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+ return _{{$contract.Type}}.Contract.{{$contract.Type}}Caller.contract.Call(opts, result, method, params...)
+ }
+
+ // Transfer initiates a plain transaction to move funds to the contract, calling
+ // its default method if one is available.
+ func (_{{$contract.Type}} *{{$contract.Type}}Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+ return _{{$contract.Type}}.Contract.{{$contract.Type}}Transactor.contract.Transfer(opts)
+ }
+
+ // Transact invokes the (paid) contract method with params as input values.
+ func (_{{$contract.Type}} *{{$contract.Type}}Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+ return _{{$contract.Type}}.Contract.{{$contract.Type}}Transactor.contract.Transact(opts, method, params...)
+ }
+
+ // Call invokes the (constant) contract method with params as input values and
+ // sets the output to result. The result type might be a single field for simple
+ // returns, a slice of interfaces for anonymous returns and a struct for named
+ // returns.
+ func (_{{$contract.Type}} *{{$contract.Type}}CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+ return _{{$contract.Type}}.Contract.contract.Call(opts, result, method, params...)
+ }
+
+ // Transfer initiates a plain transaction to move funds to the contract, calling
+ // its default method if one is available.
+ func (_{{$contract.Type}} *{{$contract.Type}}TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+ return _{{$contract.Type}}.Contract.contract.Transfer(opts)
+ }
+
+ // Transact invokes the (paid) contract method with params as input values.
+ func (_{{$contract.Type}} *{{$contract.Type}}TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+ return _{{$contract.Type}}.Contract.contract.Transact(opts, method, params...)
+ }
+
+ {{range .Calls}}
+ // {{.Normalized.Name}} is a free data retrieval call binding the contract method 0x{{printf "%x" .Original.ID}}.
+ //
+ // Solidity: {{.Original.String}}
+ func (_{{$contract.Type}} *{{$contract.Type}}Caller) {{.Normalized.Name}}(opts *bind.CallOpts {{range .Normalized.Inputs}}, {{.Name}} {{bindtype .Type $structs}} {{end}}) ({{if .Structured}}struct{ {{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type $structs}};{{end}} },{{else}}{{range .Normalized.Outputs}}{{bindtype .Type $structs}},{{end}}{{end}} error) {
+ var out []interface{}
+ err := _{{$contract.Type}}.contract.Call(opts, &out, "{{.Original.Name}}" {{range .Normalized.Inputs}}, {{.Name}}{{end}})
+ {{if .Structured}}
+ outstruct := new(struct{ {{range .Normalized.Outputs}} {{.Name}} {{bindtype .Type $structs}}; {{end}} })
+ if err != nil {
+ return *outstruct, err
+ }
+ {{range $i, $t := .Normalized.Outputs}}
+ outstruct.{{.Name}} = *abi.ConvertType(out[{{$i}}], new({{bindtype .Type $structs}})).(*{{bindtype .Type $structs}}){{end}}
+
+ return *outstruct, err
+ {{else}}
+ if err != nil {
+ return {{range $i, $_ := .Normalized.Outputs}}*new({{bindtype .Type $structs}}), {{end}} err
+ }
+ {{range $i, $t := .Normalized.Outputs}}
+ out{{$i}} := *abi.ConvertType(out[{{$i}}], new({{bindtype .Type $structs}})).(*{{bindtype .Type $structs}}){{end}}
+
+ return {{range $i, $t := .Normalized.Outputs}}out{{$i}}, {{end}} err
+ {{end}}
+ }
+
+ // {{.Normalized.Name}} is a free data retrieval call binding the contract method 0x{{printf "%x" .Original.ID}}.
+ //
+ // Solidity: {{.Original.String}}
+ func (_{{$contract.Type}} *{{$contract.Type}}Session) {{.Normalized.Name}}({{range $i, $_ := .Normalized.Inputs}}{{if ne $i 0}},{{end}} {{.Name}} {{bindtype .Type $structs}} {{end}}) ({{if .Structured}}struct{ {{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type $structs}};{{end}} }, {{else}} {{range .Normalized.Outputs}}{{bindtype .Type $structs}},{{end}} {{end}} error) {
+ return _{{$contract.Type}}.Contract.{{.Normalized.Name}}(&_{{$contract.Type}}.CallOpts {{range .Normalized.Inputs}}, {{.Name}}{{end}})
+ }
+
+ // {{.Normalized.Name}} is a free data retrieval call binding the contract method 0x{{printf "%x" .Original.ID}}.
+ //
+ // Solidity: {{.Original.String}}
+ func (_{{$contract.Type}} *{{$contract.Type}}CallerSession) {{.Normalized.Name}}({{range $i, $_ := .Normalized.Inputs}}{{if ne $i 0}},{{end}} {{.Name}} {{bindtype .Type $structs}} {{end}}) ({{if .Structured}}struct{ {{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type $structs}};{{end}} }, {{else}} {{range .Normalized.Outputs}}{{bindtype .Type $structs}},{{end}} {{end}} error) {
+ return _{{$contract.Type}}.Contract.{{.Normalized.Name}}(&_{{$contract.Type}}.CallOpts {{range .Normalized.Inputs}}, {{.Name}}{{end}})
+ }
+ {{end}}
+
+ {{range .Transacts}}
+ // {{.Normalized.Name}} is a paid mutator transaction binding the contract method 0x{{printf "%x" .Original.ID}}.
+ //
+ // Solidity: {{.Original.String}}
+ func (_{{$contract.Type}} *{{$contract.Type}}Transactor) {{.Normalized.Name}}(opts *bind.TransactOpts {{range .Normalized.Inputs}}, {{.Name}} {{bindtype .Type $structs}} {{end}}) (*types.Transaction, error) {
+ return _{{$contract.Type}}.contract.Transact(opts, "{{.Original.Name}}" {{range .Normalized.Inputs}}, {{.Name}}{{end}})
+ }
+
+ // {{.Normalized.Name}} is a paid mutator transaction binding the contract method 0x{{printf "%x" .Original.ID}}.
+ //
+ // Solidity: {{.Original.String}}
+ func (_{{$contract.Type}} *{{$contract.Type}}Session) {{.Normalized.Name}}({{range $i, $_ := .Normalized.Inputs}}{{if ne $i 0}},{{end}} {{.Name}} {{bindtype .Type $structs}} {{end}}) (*types.Transaction, error) {
+ return _{{$contract.Type}}.Contract.{{.Normalized.Name}}(&_{{$contract.Type}}.TransactOpts {{range $i, $_ := .Normalized.Inputs}}, {{.Name}}{{end}})
+ }
+
+ // {{.Normalized.Name}} is a paid mutator transaction binding the contract method 0x{{printf "%x" .Original.ID}}.
+ //
+ // Solidity: {{.Original.String}}
+ func (_{{$contract.Type}} *{{$contract.Type}}TransactorSession) {{.Normalized.Name}}({{range $i, $_ := .Normalized.Inputs}}{{if ne $i 0}},{{end}} {{.Name}} {{bindtype .Type $structs}} {{end}}) (*types.Transaction, error) {
+ return _{{$contract.Type}}.Contract.{{.Normalized.Name}}(&_{{$contract.Type}}.TransactOpts {{range $i, $_ := .Normalized.Inputs}}, {{.Name}}{{end}})
+ }
+ {{end}}
+
+ {{if .Fallback}}
+ // Fallback is a paid mutator transaction binding the contract fallback function.
+ //
+ // Solidity: {{.Fallback.Original.String}}
+ func (_{{$contract.Type}} *{{$contract.Type}}Transactor) Fallback(opts *bind.TransactOpts, calldata []byte) (*types.Transaction, error) {
+ return _{{$contract.Type}}.contract.RawTransact(opts, calldata)
+ }
+
+ // Fallback is a paid mutator transaction binding the contract fallback function.
+ //
+ // Solidity: {{.Fallback.Original.String}}
+ func (_{{$contract.Type}} *{{$contract.Type}}Session) Fallback(calldata []byte) (*types.Transaction, error) {
+ return _{{$contract.Type}}.Contract.Fallback(&_{{$contract.Type}}.TransactOpts, calldata)
+ }
+
+ // Fallback is a paid mutator transaction binding the contract fallback function.
+ //
+ // Solidity: {{.Fallback.Original.String}}
+ func (_{{$contract.Type}} *{{$contract.Type}}TransactorSession) Fallback(calldata []byte) (*types.Transaction, error) {
+ return _{{$contract.Type}}.Contract.Fallback(&_{{$contract.Type}}.TransactOpts, calldata)
+ }
+ {{end}}
+
+ {{if .Receive}}
+ // Receive is a paid mutator transaction binding the contract receive function.
+ //
+ // Solidity: {{.Receive.Original.String}}
+ func (_{{$contract.Type}} *{{$contract.Type}}Transactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error) {
+ return _{{$contract.Type}}.contract.RawTransact(opts, nil) // calldata is disallowed for receive function
+ }
+
+ // Receive is a paid mutator transaction binding the contract receive function.
+ //
+ // Solidity: {{.Receive.Original.String}}
+ func (_{{$contract.Type}} *{{$contract.Type}}Session) Receive() (*types.Transaction, error) {
+ return _{{$contract.Type}}.Contract.Receive(&_{{$contract.Type}}.TransactOpts)
+ }
+
+ // Receive is a paid mutator transaction binding the contract receive function.
+ //
+ // Solidity: {{.Receive.Original.String}}
+ func (_{{$contract.Type}} *{{$contract.Type}}TransactorSession) Receive() (*types.Transaction, error) {
+ return _{{$contract.Type}}.Contract.Receive(&_{{$contract.Type}}.TransactOpts)
+ }
+ {{end}}
+
+ {{range .Events}}
+ // {{$contract.Type}}{{.Normalized.Name}}Iterator is returned from Filter{{.Normalized.Name}} and is used to iterate over the raw logs and unpacked data for {{.Normalized.Name}} events raised by the {{$contract.Type}} contract.
+ type {{$contract.Type}}{{.Normalized.Name}}Iterator struct {
+ Event *{{$contract.Type}}{{.Normalized.Name}} // Event containing the contract specifics and raw log
+
+ contract *bind.BoundContract // Generic contract to use for unpacking event data
+ event string // Event name to use for unpacking event data
+
+ logs chan types.Log // Log channel receiving the found contract events
+ sub ethereum.Subscription // Subscription for errors, completion and termination
+ done bool // Whether the subscription completed delivering logs
+ fail error // Occurred error to stop iteration
+ }
+ // Next advances the iterator to the subsequent event, returning whether there
+ // are any more events found. In case of a retrieval or parsing error, false is
+ // returned and Error() can be queried for the exact failure.
+ func (it *{{$contract.Type}}{{.Normalized.Name}}Iterator) Next() bool {
+ // If the iterator failed, stop iterating
+ if (it.fail != nil) {
+ return false
+ }
+ // If the iterator completed, deliver directly whatever's available
+ if (it.done) {
+ select {
+ case log := <-it.logs:
+ it.Event = new({{$contract.Type}}{{.Normalized.Name}})
+ if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+ it.fail = err
+ return false
+ }
+ it.Event.Raw = log
+ return true
+
+ default:
+ return false
+ }
+ }
+ // Iterator still in progress, wait for either a data or an error event
+ select {
+ case log := <-it.logs:
+ it.Event = new({{$contract.Type}}{{.Normalized.Name}})
+ if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+ it.fail = err
+ return false
+ }
+ it.Event.Raw = log
+ return true
+
+ case err := <-it.sub.Err():
+ it.done = true
+ it.fail = err
+ return it.Next()
+ }
+ }
+ // Error returns any retrieval or parsing error occurred during filtering.
+ func (it *{{$contract.Type}}{{.Normalized.Name}}Iterator) Error() error {
+ return it.fail
+ }
+ // Close terminates the iteration process, releasing any pending underlying
+ // resources.
+ func (it *{{$contract.Type}}{{.Normalized.Name}}Iterator) Close() error {
+ it.sub.Unsubscribe()
+ return nil
+ }
+
+ // {{$contract.Type}}{{.Normalized.Name}} represents a {{.Normalized.Name}} event raised by the {{$contract.Type}} contract.
+ type {{$contract.Type}}{{.Normalized.Name}} struct { {{range .Normalized.Inputs}}
+ {{capitalise .Name}} {{if .Indexed}}{{bindtopictype .Type $structs}}{{else}}{{bindtype .Type $structs}}{{end}}; {{end}}
+ Raw types.Log // Blockchain specific contextual infos
+ }
+
+ // Filter{{.Normalized.Name}} is a free log retrieval operation binding the contract event 0x{{printf "%x" .Original.ID}}.
+ //
+ // Solidity: {{.Original.String}}
+ func (_{{$contract.Type}} *{{$contract.Type}}Filterer) Filter{{.Normalized.Name}}(opts *bind.FilterOpts{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}} []{{bindtype .Type $structs}}{{end}}{{end}}) (*{{$contract.Type}}{{.Normalized.Name}}Iterator, error) {
+ {{range .Normalized.Inputs}}
+ {{if .Indexed}}var {{.Name}}Rule []interface{}
+ for _, {{.Name}}Item := range {{.Name}} {
+ {{.Name}}Rule = append({{.Name}}Rule, {{.Name}}Item)
+ }{{end}}{{end}}
+
+ logs, sub, err := _{{$contract.Type}}.contract.FilterLogs(opts, "{{.Original.Name}}"{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}}Rule{{end}}{{end}})
+ if err != nil {
+ return nil, err
+ }
+ return &{{$contract.Type}}{{.Normalized.Name}}Iterator{contract: _{{$contract.Type}}.contract, event: "{{.Original.Name}}", logs: logs, sub: sub}, nil
+ }
+
+ // Watch{{.Normalized.Name}} is a free log subscription operation binding the contract event 0x{{printf "%x" .Original.ID}}.
+ //
+ // Solidity: {{.Original.String}}
+ func (_{{$contract.Type}} *{{$contract.Type}}Filterer) Watch{{.Normalized.Name}}(opts *bind.WatchOpts, sink chan<- *{{$contract.Type}}{{.Normalized.Name}}{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}} []{{bindtype .Type $structs}}{{end}}{{end}}) (event.Subscription, error) {
+ {{range .Normalized.Inputs}}
+ {{if .Indexed}}var {{.Name}}Rule []interface{}
+ for _, {{.Name}}Item := range {{.Name}} {
+ {{.Name}}Rule = append({{.Name}}Rule, {{.Name}}Item)
+ }{{end}}{{end}}
+
+ logs, sub, err := _{{$contract.Type}}.contract.WatchLogs(opts, "{{.Original.Name}}"{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}}Rule{{end}}{{end}})
+ if err != nil {
+ return nil, err
+ }
+ return event.NewSubscription(func(quit <-chan struct{}) error {
+ defer sub.Unsubscribe()
+ for {
+ select {
+ case log := <-logs:
+ // New log arrived, parse the event and forward to the user
+ event := new({{$contract.Type}}{{.Normalized.Name}})
+ if err := _{{$contract.Type}}.contract.UnpackLog(event, "{{.Original.Name}}", log); err != nil {
+ return err
+ }
+ event.Raw = log
+
+ select {
+ case sink <- event:
+ case err := <-sub.Err():
+ return err
+ case <-quit:
+ return nil
+ }
+ case err := <-sub.Err():
+ return err
+ case <-quit:
+ return nil
+ }
+ }
+ }), nil
+ }
+
+ // Parse{{.Normalized.Name}} is a log parse operation binding the contract event 0x{{printf "%x" .Original.ID}}.
+ //
+ // Solidity: {{.Original.String}}
+ func (_{{$contract.Type}} *{{$contract.Type}}Filterer) Parse{{.Normalized.Name}}(log types.Log) (*{{$contract.Type}}{{.Normalized.Name}}, error) {
+ event := new({{$contract.Type}}{{.Normalized.Name}})
+ if err := _{{$contract.Type}}.contract.UnpackLog(event, "{{.Original.Name}}", log); err != nil {
+ return nil, err
+ }
+ event.Raw = log
+ return event, nil
+ }
+
+ {{end}}
+{{end}}
+`
+
+// tmplSourceJava is the Java source template that the generated Java contract binding
+// is based on.
+const tmplSourceJava = `
+// This file is an automatically generated Java binding. Do not modify as any
+// change will likely be lost upon the next re-generation!
+
+package {{.Package}};
+
+import org.ethereum.geth.*;
+import java.util.*;
+
+{{$structs := .Structs}}
+{{range $contract := .Contracts}}
+{{if not .Library}}public {{end}}class {{.Type}} {
+ // ABI is the input ABI used to generate the binding from.
+ public final static String ABI = "{{.InputABI}}";
+ {{if $contract.FuncSigs}}
+ // {{.Type}}FuncSigs maps the 4-byte function signature to its string representation.
+ public final static Map {{.Type}}FuncSigs;
+ static {
+ Hashtable temp = new Hashtable();
+ {{range $strsig, $binsig := .FuncSigs}}temp.put("{{$binsig}}", "{{$strsig}}");
+ {{end}}
+ {{.Type}}FuncSigs = Collections.unmodifiableMap(temp);
+ }
+ {{end}}
+ {{if .InputBin}}
+ // BYTECODE is the compiled bytecode used for deploying new contracts.
+ public final static String BYTECODE = "0x{{.InputBin}}";
+
+ // deploy deploys a new Ethereum contract, binding an instance of {{.Type}} to it.
+ public static {{.Type}} deploy(TransactOpts auth, EthereumClient client{{range .Constructor.Inputs}}, {{bindtype .Type $structs}} {{.Name}}{{end}}) throws Exception {
+ Interfaces args = Geth.newInterfaces({{(len .Constructor.Inputs)}});
+ String bytecode = BYTECODE;
+ {{if .Libraries}}
+
+ // "link" contract to dependent libraries by deploying them first.
+ {{range $pattern, $name := .Libraries}}
+ {{capitalise $name}} {{decapitalise $name}}Inst = {{capitalise $name}}.deploy(auth, client);
+ bytecode = bytecode.replace("__${{$pattern}}$__", {{decapitalise $name}}Inst.Address.getHex().substring(2));
+ {{end}}
+ {{end}}
+ {{range $index, $element := .Constructor.Inputs}}Interface arg{{$index}} = Geth.newInterface();arg{{$index}}.set{{namedtype (bindtype .Type $structs) .Type}}({{.Name}});args.set({{$index}},arg{{$index}});
+ {{end}}
+ return new {{.Type}}(Geth.deployContract(auth, ABI, Geth.decodeFromHex(bytecode), client, args));
+ }
+
+ // Internal constructor used by contract deployment.
+ private {{.Type}}(BoundContract deployment) {
+ this.Address = deployment.getAddress();
+ this.Deployer = deployment.getDeployer();
+ this.Contract = deployment;
+ }
+ {{end}}
+
+ // Ethereum address where this contract is located at.
+ public final Address Address;
+
+ // Ethereum transaction in which this contract was deployed (if known!).
+ public final Transaction Deployer;
+
+ // Contract instance bound to a blockchain address.
+ private final BoundContract Contract;
+
+ // Creates a new instance of {{.Type}}, bound to a specific deployed contract.
+ public {{.Type}}(Address address, EthereumClient client) throws Exception {
+ this(Geth.bindContract(address, ABI, client));
+ }
+
+ {{range .Calls}}
+ {{if gt (len .Normalized.Outputs) 1}}
+ // {{capitalise .Normalized.Name}}Results is the output of a call to {{.Normalized.Name}}.
+ public class {{capitalise .Normalized.Name}}Results {
+ {{range $index, $item := .Normalized.Outputs}}public {{bindtype .Type $structs}} {{if ne .Name ""}}{{.Name}}{{else}}Return{{$index}}{{end}};
+ {{end}}
+ }
+ {{end}}
+
+ // {{.Normalized.Name}} is a free data retrieval call binding the contract method 0x{{printf "%x" .Original.ID}}.
+ //
+ // Solidity: {{.Original.String}}
+ public {{if gt (len .Normalized.Outputs) 1}}{{capitalise .Normalized.Name}}Results{{else if eq (len .Normalized.Outputs) 0}}void{{else}}{{range .Normalized.Outputs}}{{bindtype .Type $structs}}{{end}}{{end}} {{.Normalized.Name}}(CallOpts opts{{range .Normalized.Inputs}}, {{bindtype .Type $structs}} {{.Name}}{{end}}) throws Exception {
+ Interfaces args = Geth.newInterfaces({{(len .Normalized.Inputs)}});
+ {{range $index, $item := .Normalized.Inputs}}Interface arg{{$index}} = Geth.newInterface();arg{{$index}}.set{{namedtype (bindtype .Type $structs) .Type}}({{.Name}});args.set({{$index}},arg{{$index}});
+ {{end}}
+
+ Interfaces results = Geth.newInterfaces({{(len .Normalized.Outputs)}});
+ {{range $index, $item := .Normalized.Outputs}}Interface result{{$index}} = Geth.newInterface(); result{{$index}}.setDefault{{namedtype (bindtype .Type $structs) .Type}}(); results.set({{$index}}, result{{$index}});
+ {{end}}
+
+ if (opts == null) {
+ opts = Geth.newCallOpts();
+ }
+ this.Contract.call(opts, results, "{{.Original.Name}}", args);
+ {{if gt (len .Normalized.Outputs) 1}}
+ {{capitalise .Normalized.Name}}Results result = new {{capitalise .Normalized.Name}}Results();
+ {{range $index, $item := .Normalized.Outputs}}result.{{if ne .Name ""}}{{.Name}}{{else}}Return{{$index}}{{end}} = results.get({{$index}}).get{{namedtype (bindtype .Type $structs) .Type}}();
+ {{end}}
+ return result;
+ {{else}}{{range .Normalized.Outputs}}return results.get(0).get{{namedtype (bindtype .Type $structs) .Type}}();{{end}}
+ {{end}}
+ }
+ {{end}}
+
+ {{range .Transacts}}
+ // {{.Normalized.Name}} is a paid mutator transaction binding the contract method 0x{{printf "%x" .Original.ID}}.
+ //
+ // Solidity: {{.Original.String}}
+ public Transaction {{.Normalized.Name}}(TransactOpts opts{{range .Normalized.Inputs}}, {{bindtype .Type $structs}} {{.Name}}{{end}}) throws Exception {
+ Interfaces args = Geth.newInterfaces({{(len .Normalized.Inputs)}});
+ {{range $index, $item := .Normalized.Inputs}}Interface arg{{$index}} = Geth.newInterface();arg{{$index}}.set{{namedtype (bindtype .Type $structs) .Type}}({{.Name}});args.set({{$index}},arg{{$index}});
+ {{end}}
+ return this.Contract.transact(opts, "{{.Original.Name}}" , args);
+ }
+ {{end}}
+
+ {{if .Fallback}}
+ // Fallback is a paid mutator transaction binding the contract fallback function.
+ //
+ // Solidity: {{.Fallback.Original.String}}
+ public Transaction Fallback(TransactOpts opts, byte[] calldata) throws Exception {
+ return this.Contract.rawTransact(opts, calldata);
+ }
+ {{end}}
+
+ {{if .Receive}}
+ // Receive is a paid mutator transaction binding the contract receive function.
+ //
+ // Solidity: {{.Receive.Original.String}}
+ public Transaction Receive(TransactOpts opts) throws Exception {
+ return this.Contract.rawTransact(opts, null);
+ }
+ {{end}}
+}
+{{end}}
+`
diff --git a/abigen/accounts/abi/bind/util.go b/abigen/accounts/abi/bind/util.go
new file mode 100644
index 00000000..b931fbb0
--- /dev/null
+++ b/abigen/accounts/abi/bind/util.go
@@ -0,0 +1,79 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package bind
+
+import (
+ "context"
+ "errors"
+ "time"
+
+ "github.com/ethereum/go-ethereum"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/log"
+)
+
+// WaitMined waits for tx to be mined on the blockchain.
+// It stops waiting when the context is canceled.
+func WaitMined(ctx context.Context, b DeployBackend, tx *types.Transaction) (*types.Receipt, error) {
+ queryTicker := time.NewTicker(time.Second)
+ defer queryTicker.Stop()
+
+ logger := log.New("hash", tx.Hash())
+ for {
+ receipt, err := b.TransactionReceipt(ctx, tx.Hash())
+ if err == nil {
+ return receipt, nil
+ }
+
+ if errors.Is(err, ethereum.NotFound) {
+ logger.Trace("Transaction not yet mined")
+ } else {
+ logger.Trace("Receipt retrieval failed", "err", err)
+ }
+
+ // Wait for the next round.
+ select {
+ case <-ctx.Done():
+ return nil, ctx.Err()
+ case <-queryTicker.C:
+ }
+ }
+}
+
+// WaitDeployed waits for a contract deployment transaction and returns the on-chain
+// contract address when it is mined. It stops waiting when ctx is canceled.
+func WaitDeployed(ctx context.Context, b DeployBackend, tx *types.Transaction) (common.Address, error) {
+ if tx.To() != nil {
+ return common.Address{}, errors.New("tx is not contract creation")
+ }
+ receipt, err := WaitMined(ctx, b, tx)
+ if err != nil {
+ return common.Address{}, err
+ }
+ if receipt.ContractAddress == (common.Address{}) {
+ return common.Address{}, errors.New("zero address")
+ }
+ // Check that code has indeed been deployed at the address.
+ // This matters on pre-Homestead chains: OOG in the constructor
+ // could leave an empty account behind.
+ code, err := b.CodeAt(ctx, receipt.ContractAddress, nil)
+ if err == nil && len(code) == 0 {
+ err = ErrNoCodeAfterDeploy
+ }
+ return receipt.ContractAddress, err
+}
diff --git a/abigen/accounts/abi/bind/util_test.go b/abigen/accounts/abi/bind/util_test.go
new file mode 100644
index 00000000..75fbc91c
--- /dev/null
+++ b/abigen/accounts/abi/bind/util_test.go
@@ -0,0 +1,140 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package bind_test
+
+import (
+ "context"
+ "errors"
+ "math/big"
+ "testing"
+ "time"
+
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/crypto"
+)
+
+var testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
+
+var waitDeployedTests = map[string]struct {
+ code string
+ gas uint64
+ wantAddress common.Address
+ wantErr error
+}{
+ "successful deploy": {
+ code: `6060604052600a8060106000396000f360606040526008565b00`,
+ gas: 3000000,
+ wantAddress: common.HexToAddress("0x3a220f351252089d385b29beca14e27f204c296a"),
+ },
+ "empty code": {
+ code: ``,
+ gas: 300000,
+ wantErr: bind.ErrNoCodeAfterDeploy,
+ wantAddress: common.HexToAddress("0x3a220f351252089d385b29beca14e27f204c296a"),
+ },
+}
+
+func TestWaitDeployed(t *testing.T) {
+ for name, test := range waitDeployedTests {
+ backend := backends.NewSimulatedBackend(
+ core.GenesisAlloc{
+ crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)},
+ },
+ 10000000,
+ )
+ defer backend.Close()
+
+ // Create the transaction
+ head, _ := backend.HeaderByNumber(context.Background(), nil) // Should be child's, good enough
+ gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1))
+
+ tx := types.NewContractCreation(0, big.NewInt(0), test.gas, gasPrice, common.FromHex(test.code))
+ tx, _ = types.SignTx(tx, types.HomesteadSigner{}, testKey)
+
+ // Wait for it to get mined in the background.
+ var (
+ err error
+ address common.Address
+ mined = make(chan struct{})
+ ctx = context.Background()
+ )
+ go func() {
+ address, err = bind.WaitDeployed(ctx, backend, tx)
+ close(mined)
+ }()
+
+ // Send and mine the transaction.
+ backend.SendTransaction(ctx, tx)
+ backend.Commit()
+
+ select {
+ case <-mined:
+ if err != test.wantErr {
+ t.Errorf("test %q: error mismatch: want %q, got %q", name, test.wantErr, err)
+ }
+ if address != test.wantAddress {
+ t.Errorf("test %q: unexpected contract address %s", name, address.Hex())
+ }
+ case <-time.After(2 * time.Second):
+ t.Errorf("test %q: timeout", name)
+ }
+ }
+}
+
+func TestWaitDeployedCornerCases(t *testing.T) {
+ backend := backends.NewSimulatedBackend(
+ core.GenesisAlloc{
+ crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)},
+ },
+ 10000000,
+ )
+ defer backend.Close()
+
+ head, _ := backend.HeaderByNumber(context.Background(), nil) // Should be child's, good enough
+ gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1))
+
+ // Create a transaction to an account.
+ code := "6060604052600a8060106000396000f360606040526008565b00"
+ tx := types.NewTransaction(0, common.HexToAddress("0x01"), big.NewInt(0), 3000000, gasPrice, common.FromHex(code))
+ tx, _ = types.SignTx(tx, types.HomesteadSigner{}, testKey)
+ ctx, cancel := context.WithCancel(context.Background())
+ defer cancel()
+ backend.SendTransaction(ctx, tx)
+ backend.Commit()
+ notContentCreation := errors.New("tx is not contract creation")
+ if _, err := bind.WaitDeployed(ctx, backend, tx); err.Error() != notContentCreation.Error() {
+ t.Errorf("error missmatch: want %q, got %q, ", notContentCreation, err)
+ }
+
+ // Create a transaction that is not mined.
+ tx = types.NewContractCreation(1, big.NewInt(0), 3000000, gasPrice, common.FromHex(code))
+ tx, _ = types.SignTx(tx, types.HomesteadSigner{}, testKey)
+
+ go func() {
+ contextCanceled := errors.New("context canceled")
+ if _, err := bind.WaitDeployed(ctx, backend, tx); err.Error() != contextCanceled.Error() {
+ t.Errorf("error missmatch: want %q, got %q, ", contextCanceled, err)
+ }
+ }()
+
+ backend.SendTransaction(ctx, tx)
+ cancel()
+}
diff --git a/abigen/accounts/abi/doc.go b/abigen/accounts/abi/doc.go
new file mode 100644
index 00000000..82420685
--- /dev/null
+++ b/abigen/accounts/abi/doc.go
@@ -0,0 +1,26 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+// Package abi implements the Ethereum ABI (Application Binary
+// Interface).
+//
+// The Ethereum ABI is strongly typed, known at compile time
+// and static. This ABI will handle basic type casting; unsigned
+// to signed and visa versa. It does not handle slice casting such
+// as unsigned slice to signed slice. Bit size type casting is also
+// handled. ints with a bit size of 32 will be properly cast to int256,
+// etc.
+package abi
diff --git a/abigen/accounts/abi/error.go b/abigen/accounts/abi/error.go
new file mode 100644
index 00000000..f53c996d
--- /dev/null
+++ b/abigen/accounts/abi/error.go
@@ -0,0 +1,93 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package abi
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "strings"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/crypto"
+)
+
+type Error struct {
+ Name string
+ Inputs Arguments
+ str string
+
+ // Sig contains the string signature according to the ABI spec.
+ // e.g. error foo(uint32 a, int b) = "foo(uint32,int256)"
+ // Please note that "int" is substitute for its canonical representation "int256"
+ Sig string
+
+ // ID returns the canonical representation of the error's signature used by the
+ // abi definition to identify event names and types.
+ ID common.Hash
+}
+
+func NewError(name string, inputs Arguments) Error {
+ // sanitize inputs to remove inputs without names
+ // and precompute string and sig representation.
+ names := make([]string, len(inputs))
+ types := make([]string, len(inputs))
+ for i, input := range inputs {
+ if input.Name == "" {
+ inputs[i] = Argument{
+ Name: fmt.Sprintf("arg%d", i),
+ Indexed: input.Indexed,
+ Type: input.Type,
+ }
+ } else {
+ inputs[i] = input
+ }
+ // string representation
+ names[i] = fmt.Sprintf("%v %v", input.Type, inputs[i].Name)
+ if input.Indexed {
+ names[i] = fmt.Sprintf("%v indexed %v", input.Type, inputs[i].Name)
+ }
+ // sig representation
+ types[i] = input.Type.String()
+ }
+
+ str := fmt.Sprintf("error %v(%v)", name, strings.Join(names, ", "))
+ sig := fmt.Sprintf("%v(%v)", name, strings.Join(types, ","))
+ id := common.BytesToHash(crypto.Keccak256([]byte(sig)))
+
+ return Error{
+ Name: name,
+ Inputs: inputs,
+ str: str,
+ Sig: sig,
+ ID: id,
+ }
+}
+
+func (e *Error) String() string {
+ return e.str
+}
+
+func (e *Error) Unpack(data []byte) (interface{}, error) {
+ if len(data) < 4 {
+ return "", errors.New("invalid data for unpacking")
+ }
+ if !bytes.Equal(data[:4], e.ID[:4]) {
+ return "", errors.New("invalid data for unpacking")
+ }
+ return e.Inputs.Unpack(data[4:])
+}
diff --git a/abigen/accounts/abi/error_handling.go b/abigen/accounts/abi/error_handling.go
new file mode 100644
index 00000000..f0f71b6c
--- /dev/null
+++ b/abigen/accounts/abi/error_handling.go
@@ -0,0 +1,82 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package abi
+
+import (
+ "errors"
+ "fmt"
+ "reflect"
+)
+
+var (
+ errBadBool = errors.New("abi: improperly encoded boolean value")
+)
+
+// formatSliceString formats the reflection kind with the given slice size
+// and returns a formatted string representation.
+func formatSliceString(kind reflect.Kind, sliceSize int) string {
+ if sliceSize == -1 {
+ return fmt.Sprintf("[]%v", kind)
+ }
+ return fmt.Sprintf("[%d]%v", sliceSize, kind)
+}
+
+// sliceTypeCheck checks that the given slice can by assigned to the reflection
+// type in t.
+func sliceTypeCheck(t Type, val reflect.Value) error {
+ if val.Kind() != reflect.Slice && val.Kind() != reflect.Array {
+ return typeErr(formatSliceString(t.GetType().Kind(), t.Size), val.Type())
+ }
+
+ if t.T == ArrayTy && val.Len() != t.Size {
+ return typeErr(formatSliceString(t.Elem.GetType().Kind(), t.Size), formatSliceString(val.Type().Elem().Kind(), val.Len()))
+ }
+
+ if t.Elem.T == SliceTy || t.Elem.T == ArrayTy {
+ if val.Len() > 0 {
+ return sliceTypeCheck(*t.Elem, val.Index(0))
+ }
+ }
+
+ if val.Type().Elem().Kind() != t.Elem.GetType().Kind() {
+ return typeErr(formatSliceString(t.Elem.GetType().Kind(), t.Size), val.Type())
+ }
+ return nil
+}
+
+// typeCheck checks that the given reflection value can be assigned to the reflection
+// type in t.
+func typeCheck(t Type, value reflect.Value) error {
+ if t.T == SliceTy || t.T == ArrayTy {
+ return sliceTypeCheck(t, value)
+ }
+
+ // Check base type validity. Element types will be checked later on.
+ if t.GetType().Kind() != value.Kind() {
+ return typeErr(t.GetType().Kind(), value.Kind())
+ } else if t.T == FixedBytesTy && t.Size != value.Len() {
+ return typeErr(t.GetType(), value.Type())
+ } else {
+ return nil
+ }
+
+}
+
+// typeErr returns a formatted type casting error.
+func typeErr(expected, got interface{}) error {
+ return fmt.Errorf("abi: cannot use %v as type %v as argument", got, expected)
+}
diff --git a/abigen/accounts/abi/event.go b/abigen/accounts/abi/event.go
new file mode 100644
index 00000000..28434aef
--- /dev/null
+++ b/abigen/accounts/abi/event.go
@@ -0,0 +1,134 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package abi
+
+import (
+ "fmt"
+ "strings"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/crypto"
+)
+
+// Event is an event potentially triggered by the EVM's LOG mechanism. The Event
+// holds type information (inputs) about the yielded output. Anonymous events
+// don't get the signature canonical representation as the first LOG topic.
+type Event struct {
+ // Name is the event name used for internal representation. It's derived from
+ // the raw name and a suffix will be added in the case of event overloading.
+ //
+ // e.g.
+ // These are two events that have the same name:
+ // * foo(int,int)
+ // * foo(uint,uint)
+ // The event name of the first one will be resolved as foo while the second one
+ // will be resolved as foo0.
+ Name string
+
+ // RawName is the raw event name parsed from ABI.
+ RawName string
+ Anonymous bool
+ Inputs Arguments
+ str string
+
+ // Sig contains the string signature according to the ABI spec.
+ // e.g. event foo(uint32 a, int b) = "foo(uint32,int256)"
+ // Please note that "int" is substitute for its canonical representation "int256"
+ Sig string
+
+ // ID returns the canonical representation of the event's signature used by the
+ // abi definition to identify event names and types.
+ ID common.Hash
+}
+
+// NewEvent creates a new Event.
+// It sanitizes the input arguments to remove unnamed arguments.
+// It also precomputes the id, signature and string representation
+// of the event.
+func NewEvent(name, rawName string, anonymous bool, inputs Arguments, chain Chain) Event {
+ // sanitize inputs to remove inputs without names
+ // and precompute string and sig representation.
+ names := make([]string, len(inputs))
+ types := make([]string, len(inputs))
+ for i, input := range inputs {
+ if input.Name == "" {
+ inputs[i] = Argument{
+ Name: fmt.Sprintf("arg%d", i),
+ Indexed: input.Indexed,
+ Type: input.Type,
+ }
+ } else {
+ inputs[i] = input
+ }
+ // string representation
+ names[i] = fmt.Sprintf("%v %v", input.Type, inputs[i].Name)
+ if input.Indexed {
+ names[i] = fmt.Sprintf("%v indexed %v", input.Type, inputs[i].Name)
+ }
+ // sig representation
+ types[i] = input.Type.String()
+ }
+
+ str := fmt.Sprintf("event %v(%v)", rawName, strings.Join(names, ", "))
+ sig := fmt.Sprintf("%v(%v)", rawName, strings.Join(types, ","))
+ var id common.Hash
+ switch chain {
+ case Starknet:
+ id = getSelectorFromName(name)
+ case Ethereum:
+ id = common.BytesToHash(crypto.Keccak256([]byte(sig)))
+ }
+
+ return Event{
+ Name: name,
+ RawName: rawName,
+ Anonymous: anonymous,
+ Inputs: inputs,
+ str: str,
+ Sig: sig,
+ ID: id,
+ }
+}
+
+func (e Event) String() string {
+ return e.str
+}
+
+func getSelectorFromName(funcName string) common.Hash {
+ kec := crypto.Keccak256([]byte(funcName))
+
+ maskedKec := maskBits(250, 8, kec)
+ return common.BytesToHash(maskedKec)
+}
+
+// mask excess bits
+func maskBits(mask, wordSize int, slice []byte) (ret []byte) {
+ excess := len(slice)*wordSize - mask
+ for _, by := range slice {
+ if excess > 0 {
+ if excess > wordSize {
+ excess = excess - wordSize
+ continue
+ }
+ by <<= excess
+ by >>= excess
+ excess = 0
+ }
+ ret = append(ret, by)
+ }
+ return ret
+}
diff --git a/abigen/accounts/abi/event_test.go b/abigen/accounts/abi/event_test.go
new file mode 100644
index 00000000..3332f8a0
--- /dev/null
+++ b/abigen/accounts/abi/event_test.go
@@ -0,0 +1,390 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package abi
+
+import (
+ "bytes"
+ "encoding/hex"
+ "encoding/json"
+ "math/big"
+ "reflect"
+ "strings"
+ "testing"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/crypto"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+var jsonEventTransfer = []byte(`{
+ "anonymous": false,
+ "inputs": [
+ {
+ "indexed": true, "name": "from", "type": "address"
+ }, {
+ "indexed": true, "name": "to", "type": "address"
+ }, {
+ "indexed": false, "name": "value", "type": "uint256"
+ }],
+ "name": "Transfer",
+ "type": "event"
+}`)
+
+var jsonEventPledge = []byte(`{
+ "anonymous": false,
+ "inputs": [{
+ "indexed": false, "name": "who", "type": "address"
+ }, {
+ "indexed": false, "name": "wad", "type": "uint128"
+ }, {
+ "indexed": false, "name": "currency", "type": "bytes3"
+ }],
+ "name": "Pledge",
+ "type": "event"
+}`)
+
+var jsonEventMixedCase = []byte(`{
+ "anonymous": false,
+ "inputs": [{
+ "indexed": false, "name": "value", "type": "uint256"
+ }, {
+ "indexed": false, "name": "_value", "type": "uint256"
+ }, {
+ "indexed": false, "name": "Value", "type": "uint256"
+ }],
+ "name": "MixedCase",
+ "type": "event"
+ }`)
+
+// 1000000
+var transferData1 = "00000000000000000000000000000000000000000000000000000000000f4240"
+
+// "0x00Ce0d46d924CC8437c806721496599FC3FFA268", 2218516807680, "usd"
+var pledgeData1 = "00000000000000000000000000ce0d46d924cc8437c806721496599fc3ffa2680000000000000000000000000000000000000000000000000000020489e800007573640000000000000000000000000000000000000000000000000000000000"
+
+// 1000000,2218516807680,1000001
+var mixedCaseData1 = "00000000000000000000000000000000000000000000000000000000000f42400000000000000000000000000000000000000000000000000000020489e8000000000000000000000000000000000000000000000000000000000000000f4241"
+
+func TestEventId(t *testing.T) {
+ var table = []struct {
+ definition string
+ expectations map[string]common.Hash
+ }{
+ {
+ definition: `[
+ { "type" : "event", "name" : "Balance", "inputs": [{ "name" : "in", "type": "uint256" }] },
+ { "type" : "event", "name" : "Check", "inputs": [{ "name" : "t", "type": "address" }, { "name": "b", "type": "uint256" }] }
+ ]`,
+ expectations: map[string]common.Hash{
+ "Balance": crypto.Keccak256Hash([]byte("Balance(uint256)")),
+ "Check": crypto.Keccak256Hash([]byte("Check(address,uint256)")),
+ },
+ },
+ }
+
+ for _, test := range table {
+ abi, err := JSON(strings.NewReader(test.definition))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ for name, event := range abi.Events {
+ if event.ID != test.expectations[name] {
+ t.Errorf("expected id to be %x, got %x", test.expectations[name], event.ID)
+ }
+ }
+ }
+}
+
+func TestEventString(t *testing.T) {
+ var table = []struct {
+ definition string
+ expectations map[string]string
+ }{
+ {
+ definition: `[
+ { "type" : "event", "name" : "Balance", "inputs": [{ "name" : "in", "type": "uint256" }] },
+ { "type" : "event", "name" : "Check", "inputs": [{ "name" : "t", "type": "address" }, { "name": "b", "type": "uint256" }] },
+ { "type" : "event", "name" : "Transfer", "inputs": [{ "name": "from", "type": "address", "indexed": true }, { "name": "to", "type": "address", "indexed": true }, { "name": "value", "type": "uint256" }] }
+ ]`,
+ expectations: map[string]string{
+ "Balance": "event Balance(uint256 in)",
+ "Check": "event Check(address t, uint256 b)",
+ "Transfer": "event Transfer(address indexed from, address indexed to, uint256 value)",
+ },
+ },
+ }
+
+ for _, test := range table {
+ abi, err := JSON(strings.NewReader(test.definition))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ for name, event := range abi.Events {
+ if event.String() != test.expectations[name] {
+ t.Errorf("expected string to be %s, got %s", test.expectations[name], event.String())
+ }
+ }
+ }
+}
+
+// TestEventMultiValueWithArrayUnpack verifies that array fields will be counted after parsing array.
+func TestEventMultiValueWithArrayUnpack(t *testing.T) {
+ definition := `[{"name": "test", "type": "event", "inputs": [{"indexed": false, "name":"value1", "type":"uint8[2]"},{"indexed": false, "name":"value2", "type":"uint8"}]}]`
+ abi, err := JSON(strings.NewReader(definition))
+ require.NoError(t, err)
+ var b bytes.Buffer
+ var i uint8 = 1
+ for ; i <= 3; i++ {
+ b.Write(packNum(reflect.ValueOf(i)))
+ }
+ unpacked, err := abi.Unpack("test", b.Bytes())
+ require.NoError(t, err)
+ require.Equal(t, [2]uint8{1, 2}, unpacked[0])
+ require.Equal(t, uint8(3), unpacked[1])
+}
+
+func TestEventTupleUnpack(t *testing.T) {
+
+ type EventTransfer struct {
+ Value *big.Int
+ }
+
+ type EventTransferWithTag struct {
+ // this is valid because `value` is not exportable,
+ // so value is only unmarshalled into `Value1`.
+ value *big.Int //lint:ignore U1000 unused field is part of test
+ Value1 *big.Int `abi:"value"`
+ }
+
+ type BadEventTransferWithSameFieldAndTag struct {
+ Value *big.Int
+ Value1 *big.Int `abi:"value"`
+ }
+
+ type BadEventTransferWithDuplicatedTag struct {
+ Value1 *big.Int `abi:"value"`
+ Value2 *big.Int `abi:"value"`
+ }
+
+ type BadEventTransferWithEmptyTag struct {
+ Value *big.Int `abi:""`
+ }
+
+ type EventPledge struct {
+ Who common.Address
+ Wad *big.Int
+ Currency [3]byte
+ }
+
+ type BadEventPledge struct {
+ Who string
+ Wad int
+ Currency [3]byte
+ }
+
+ type EventMixedCase struct {
+ Value1 *big.Int `abi:"value"`
+ Value2 *big.Int `abi:"_value"`
+ Value3 *big.Int `abi:"Value"`
+ }
+
+ bigint := new(big.Int)
+ bigintExpected := big.NewInt(1000000)
+ bigintExpected2 := big.NewInt(2218516807680)
+ bigintExpected3 := big.NewInt(1000001)
+ addr := common.HexToAddress("0x00Ce0d46d924CC8437c806721496599FC3FFA268")
+ var testCases = []struct {
+ data string
+ dest interface{}
+ expected interface{}
+ jsonLog []byte
+ error string
+ name string
+ }{{
+ transferData1,
+ &EventTransfer{},
+ &EventTransfer{Value: bigintExpected},
+ jsonEventTransfer,
+ "",
+ "Can unpack ERC20 Transfer event into structure",
+ }, {
+ transferData1,
+ &[]interface{}{&bigint},
+ &[]interface{}{&bigintExpected},
+ jsonEventTransfer,
+ "",
+ "Can unpack ERC20 Transfer event into slice",
+ }, {
+ transferData1,
+ &EventTransferWithTag{},
+ &EventTransferWithTag{Value1: bigintExpected},
+ jsonEventTransfer,
+ "",
+ "Can unpack ERC20 Transfer event into structure with abi: tag",
+ }, {
+ transferData1,
+ &BadEventTransferWithDuplicatedTag{},
+ &BadEventTransferWithDuplicatedTag{},
+ jsonEventTransfer,
+ "struct: abi tag in 'Value2' already mapped",
+ "Can not unpack ERC20 Transfer event with duplicated abi tag",
+ }, {
+ transferData1,
+ &BadEventTransferWithSameFieldAndTag{},
+ &BadEventTransferWithSameFieldAndTag{},
+ jsonEventTransfer,
+ "abi: multiple variables maps to the same abi field 'value'",
+ "Can not unpack ERC20 Transfer event with a field and a tag mapping to the same abi variable",
+ }, {
+ transferData1,
+ &BadEventTransferWithEmptyTag{},
+ &BadEventTransferWithEmptyTag{},
+ jsonEventTransfer,
+ "struct: abi tag in 'Value' is empty",
+ "Can not unpack ERC20 Transfer event with an empty tag",
+ }, {
+ pledgeData1,
+ &EventPledge{},
+ &EventPledge{
+ addr,
+ bigintExpected2,
+ [3]byte{'u', 's', 'd'}},
+ jsonEventPledge,
+ "",
+ "Can unpack Pledge event into structure",
+ }, {
+ pledgeData1,
+ &[]interface{}{&common.Address{}, &bigint, &[3]byte{}},
+ &[]interface{}{
+ &addr,
+ &bigintExpected2,
+ &[3]byte{'u', 's', 'd'}},
+ jsonEventPledge,
+ "",
+ "Can unpack Pledge event into slice",
+ }, {
+ pledgeData1,
+ &[3]interface{}{&common.Address{}, &bigint, &[3]byte{}},
+ &[3]interface{}{
+ &addr,
+ &bigintExpected2,
+ &[3]byte{'u', 's', 'd'}},
+ jsonEventPledge,
+ "",
+ "Can unpack Pledge event into an array",
+ }, {
+ pledgeData1,
+ &[]interface{}{new(int), 0, 0},
+ &[]interface{}{},
+ jsonEventPledge,
+ "abi: cannot unmarshal common.Address in to int",
+ "Can not unpack Pledge event into slice with wrong types",
+ }, {
+ pledgeData1,
+ &BadEventPledge{},
+ &BadEventPledge{},
+ jsonEventPledge,
+ "abi: cannot unmarshal common.Address in to string",
+ "Can not unpack Pledge event into struct with wrong filed types",
+ }, {
+ pledgeData1,
+ &[]interface{}{common.Address{}, new(big.Int)},
+ &[]interface{}{},
+ jsonEventPledge,
+ "abi: insufficient number of arguments for unpack, want 3, got 2",
+ "Can not unpack Pledge event into too short slice",
+ }, {
+ pledgeData1,
+ new(map[string]interface{}),
+ &[]interface{}{},
+ jsonEventPledge,
+ "abi:[2] cannot unmarshal tuple in to map[string]interface {}",
+ "Can not unpack Pledge event into map",
+ }, {
+ mixedCaseData1,
+ &EventMixedCase{},
+ &EventMixedCase{Value1: bigintExpected, Value2: bigintExpected2, Value3: bigintExpected3},
+ jsonEventMixedCase,
+ "",
+ "Can unpack abi variables with mixed case",
+ }}
+
+ for _, tc := range testCases {
+ assert := assert.New(t)
+ tc := tc
+ t.Run(tc.name, func(t *testing.T) {
+ err := unpackTestEventData(tc.dest, tc.data, tc.jsonLog, assert)
+ if tc.error == "" {
+ assert.Nil(err, "Should be able to unpack event data.")
+ assert.Equal(tc.expected, tc.dest, tc.name)
+ } else {
+ assert.EqualError(err, tc.error, tc.name)
+ }
+ })
+ }
+}
+
+func unpackTestEventData(dest interface{}, hexData string, jsonEvent []byte, assert *assert.Assertions) error {
+ data, err := hex.DecodeString(hexData)
+ assert.NoError(err, "Hex data should be a correct hex-string")
+ var e Event
+ assert.NoError(json.Unmarshal(jsonEvent, &e), "Should be able to unmarshal event ABI")
+ a := ABI{Events: map[string]Event{"e": e}}
+ return a.UnpackIntoInterface(dest, "e", data)
+}
+
+// TestEventUnpackIndexed verifies that indexed field will be skipped by event decoder.
+func TestEventUnpackIndexed(t *testing.T) {
+ definition := `[{"name": "test", "type": "event", "inputs": [{"indexed": true, "name":"value1", "type":"uint8"},{"indexed": false, "name":"value2", "type":"uint8"}]}]`
+ type testStruct struct {
+ Value1 uint8 // indexed
+ Value2 uint8
+ }
+ abi, err := JSON(strings.NewReader(definition))
+ require.NoError(t, err)
+ var b bytes.Buffer
+ b.Write(packNum(reflect.ValueOf(uint8(8))))
+ var rst testStruct
+ require.NoError(t, abi.UnpackIntoInterface(&rst, "test", b.Bytes()))
+ require.Equal(t, uint8(0), rst.Value1)
+ require.Equal(t, uint8(8), rst.Value2)
+}
+
+// TestEventIndexedWithArrayUnpack verifies that decoder will not overflow when static array is indexed input.
+func TestEventIndexedWithArrayUnpack(t *testing.T) {
+ definition := `[{"name": "test", "type": "event", "inputs": [{"indexed": true, "name":"value1", "type":"uint8[2]"},{"indexed": false, "name":"value2", "type":"string"}]}]`
+ type testStruct struct {
+ Value1 [2]uint8 // indexed
+ Value2 string
+ }
+ abi, err := JSON(strings.NewReader(definition))
+ require.NoError(t, err)
+ var b bytes.Buffer
+ stringOut := "abc"
+ // number of fields that will be encoded * 32
+ b.Write(packNum(reflect.ValueOf(32)))
+ b.Write(packNum(reflect.ValueOf(len(stringOut))))
+ b.Write(common.RightPadBytes([]byte(stringOut), 32))
+
+ var rst testStruct
+ require.NoError(t, abi.UnpackIntoInterface(&rst, "test", b.Bytes()))
+ require.Equal(t, [2]uint8{0, 0}, rst.Value1)
+ require.Equal(t, stringOut, rst.Value2)
+}
diff --git a/abigen/accounts/abi/method.go b/abigen/accounts/abi/method.go
new file mode 100644
index 00000000..f69e3ee9
--- /dev/null
+++ b/abigen/accounts/abi/method.go
@@ -0,0 +1,167 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package abi
+
+import (
+ "fmt"
+ "strings"
+
+ "github.com/ethereum/go-ethereum/crypto"
+)
+
+// FunctionType represents different types of functions a contract might have.
+type FunctionType int
+
+const (
+ // Constructor represents the constructor of the contract.
+ // The constructor function is called while deploying a contract.
+ Constructor FunctionType = iota
+ // Fallback represents the fallback function.
+ // This function is executed if no other function matches the given function
+ // signature and no receive function is specified.
+ Fallback
+ // Receive represents the receive function.
+ // This function is executed on plain Ether transfers.
+ Receive
+ // Function represents a normal function.
+ Function
+)
+
+// Method represents a callable given a `Name` and whether the method is a constant.
+// If the method is `Const` no transaction needs to be created for this
+// particular Method call. It can easily be simulated using a local VM.
+// For example a `Balance()` method only needs to retrieve something
+// from the storage and therefore requires no Tx to be sent to the
+// network. A method such as `Transact` does require a Tx and thus will
+// be flagged `false`.
+// Input specifies the required input parameters for this gives method.
+type Method struct {
+ // Name is the method name used for internal representation. It's derived from
+ // the raw name and a suffix will be added in the case of a function overload.
+ //
+ // e.g.
+ // These are two functions that have the same name:
+ // * foo(int,int)
+ // * foo(uint,uint)
+ // The method name of the first one will be resolved as foo while the second one
+ // will be resolved as foo0.
+ Name string
+ RawName string // RawName is the raw method name parsed from ABI
+
+ // Type indicates whether the method is a
+ // special fallback introduced in solidity v0.6.0
+ Type FunctionType
+
+ // StateMutability indicates the mutability state of method,
+ // the default value is nonpayable. It can be empty if the abi
+ // is generated by legacy compiler.
+ StateMutability string
+
+ // Legacy indicators generated by compiler before v0.6.0
+ Constant bool
+ Payable bool
+
+ Inputs Arguments
+ Outputs Arguments
+ str string
+ // Sig returns the methods string signature according to the ABI spec.
+ // e.g. function foo(uint32 a, int b) = "foo(uint32,int256)"
+ // Please note that "int" is substitute for its canonical representation "int256"
+ Sig string
+ // ID returns the canonical representation of the method's signature used by the
+ // abi definition to identify method names and types.
+ ID []byte
+}
+
+// NewMethod creates a new Method.
+// A method should always be created using NewMethod.
+// It also precomputes the sig representation and the string representation
+// of the method.
+func NewMethod(name string, rawName string, funType FunctionType, mutability string, isConst, isPayable bool, inputs Arguments, outputs Arguments) Method {
+ var (
+ types = make([]string, len(inputs))
+ inputNames = make([]string, len(inputs))
+ outputNames = make([]string, len(outputs))
+ )
+ for i, input := range inputs {
+ inputNames[i] = fmt.Sprintf("%v %v", input.Type, input.Name)
+ types[i] = input.Type.String()
+ }
+ for i, output := range outputs {
+ outputNames[i] = output.Type.String()
+ if len(output.Name) > 0 {
+ outputNames[i] += fmt.Sprintf(" %v", output.Name)
+ }
+ }
+ // calculate the signature and method id. Note only function
+ // has meaningful signature and id.
+ var (
+ sig string
+ id []byte
+ )
+ if funType == Function {
+ sig = fmt.Sprintf("%v(%v)", rawName, strings.Join(types, ","))
+ id = crypto.Keccak256([]byte(sig))[:4]
+ }
+ // Extract meaningful state mutability of solidity method.
+ // If it's default value, never print it.
+ state := mutability
+ if state == "nonpayable" {
+ state = ""
+ }
+ if state != "" {
+ state = state + " "
+ }
+ identity := fmt.Sprintf("function %v", rawName)
+ if funType == Fallback {
+ identity = "fallback"
+ } else if funType == Receive {
+ identity = "receive"
+ } else if funType == Constructor {
+ identity = "constructor"
+ }
+ str := fmt.Sprintf("%v(%v) %sreturns(%v)", identity, strings.Join(inputNames, ", "), state, strings.Join(outputNames, ", "))
+
+ return Method{
+ Name: name,
+ RawName: rawName,
+ Type: funType,
+ StateMutability: mutability,
+ Constant: isConst,
+ Payable: isPayable,
+ Inputs: inputs,
+ Outputs: outputs,
+ str: str,
+ Sig: sig,
+ ID: id,
+ }
+}
+
+func (method Method) String() string {
+ return method.str
+}
+
+// IsConstant returns the indicator whether the method is read-only.
+func (method Method) IsConstant() bool {
+ return method.StateMutability == "view" || method.StateMutability == "pure" || method.Constant
+}
+
+// IsPayable returns the indicator whether the method can process
+// plain ether transfers.
+func (method Method) IsPayable() bool {
+ return method.StateMutability == "payable" || method.Payable
+}
diff --git a/abigen/accounts/abi/method_test.go b/abigen/accounts/abi/method_test.go
new file mode 100644
index 00000000..395a5289
--- /dev/null
+++ b/abigen/accounts/abi/method_test.go
@@ -0,0 +1,145 @@
+// Copyright 2018 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package abi
+
+import (
+ "strings"
+ "testing"
+)
+
+const methoddata = `
+[
+ {"type": "function", "name": "balance", "stateMutability": "view"},
+ {"type": "function", "name": "send", "inputs": [{ "name": "amount", "type": "uint256" }]},
+ {"type": "function", "name": "transfer", "inputs": [{"name": "from", "type": "address"}, {"name": "to", "type": "address"}, {"name": "value", "type": "uint256"}], "outputs": [{"name": "success", "type": "bool"}]},
+ {"constant":false,"inputs":[{"components":[{"name":"x","type":"uint256"},{"name":"y","type":"uint256"}],"name":"a","type":"tuple"}],"name":"tuple","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},
+ {"constant":false,"inputs":[{"components":[{"name":"x","type":"uint256"},{"name":"y","type":"uint256"}],"name":"a","type":"tuple[]"}],"name":"tupleSlice","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},
+ {"constant":false,"inputs":[{"components":[{"name":"x","type":"uint256"},{"name":"y","type":"uint256"}],"name":"a","type":"tuple[5]"}],"name":"tupleArray","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},
+ {"constant":false,"inputs":[{"components":[{"name":"x","type":"uint256"},{"name":"y","type":"uint256"}],"name":"a","type":"tuple[5][]"}],"name":"complexTuple","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},
+ {"stateMutability":"nonpayable","type":"fallback"},
+ {"stateMutability":"payable","type":"receive"}
+]`
+
+func TestMethodString(t *testing.T) {
+ var table = []struct {
+ method string
+ expectation string
+ }{
+ {
+ method: "balance",
+ expectation: "function balance() view returns()",
+ },
+ {
+ method: "send",
+ expectation: "function send(uint256 amount) returns()",
+ },
+ {
+ method: "transfer",
+ expectation: "function transfer(address from, address to, uint256 value) returns(bool success)",
+ },
+ {
+ method: "tuple",
+ expectation: "function tuple((uint256,uint256) a) returns()",
+ },
+ {
+ method: "tupleArray",
+ expectation: "function tupleArray((uint256,uint256)[5] a) returns()",
+ },
+ {
+ method: "tupleSlice",
+ expectation: "function tupleSlice((uint256,uint256)[] a) returns()",
+ },
+ {
+ method: "complexTuple",
+ expectation: "function complexTuple((uint256,uint256)[5][] a) returns()",
+ },
+ {
+ method: "fallback",
+ expectation: "fallback() returns()",
+ },
+ {
+ method: "receive",
+ expectation: "receive() payable returns()",
+ },
+ }
+
+ abi, err := JSON(strings.NewReader(methoddata))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ for _, test := range table {
+ var got string
+ if test.method == "fallback" {
+ got = abi.Fallback.String()
+ } else if test.method == "receive" {
+ got = abi.Receive.String()
+ } else {
+ got = abi.Methods[test.method].String()
+ }
+ if got != test.expectation {
+ t.Errorf("expected string to be %s, got %s", test.expectation, got)
+ }
+ }
+}
+
+func TestMethodSig(t *testing.T) {
+ var cases = []struct {
+ method string
+ expect string
+ }{
+ {
+ method: "balance",
+ expect: "balance()",
+ },
+ {
+ method: "send",
+ expect: "send(uint256)",
+ },
+ {
+ method: "transfer",
+ expect: "transfer(address,address,uint256)",
+ },
+ {
+ method: "tuple",
+ expect: "tuple((uint256,uint256))",
+ },
+ {
+ method: "tupleArray",
+ expect: "tupleArray((uint256,uint256)[5])",
+ },
+ {
+ method: "tupleSlice",
+ expect: "tupleSlice((uint256,uint256)[])",
+ },
+ {
+ method: "complexTuple",
+ expect: "complexTuple((uint256,uint256)[5][])",
+ },
+ }
+ abi, err := JSON(strings.NewReader(methoddata))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ for _, test := range cases {
+ got := abi.Methods[test.method].Sig
+ if got != test.expect {
+ t.Errorf("expected string to be %s, got %s", test.expect, got)
+ }
+ }
+}
diff --git a/abigen/accounts/abi/pack.go b/abigen/accounts/abi/pack.go
new file mode 100644
index 00000000..0cd91cb4
--- /dev/null
+++ b/abigen/accounts/abi/pack.go
@@ -0,0 +1,85 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package abi
+
+import (
+ "errors"
+ "fmt"
+ "math/big"
+ "reflect"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/math"
+)
+
+// packBytesSlice packs the given bytes as [L, V] as the canonical representation
+// bytes slice.
+func packBytesSlice(bytes []byte, l int) []byte {
+ len := packNum(reflect.ValueOf(l))
+ return append(len, common.RightPadBytes(bytes, (l+31)/32*32)...)
+}
+
+// packElement packs the given reflect value according to the abi specification in
+// t.
+func packElement(t Type, reflectValue reflect.Value) ([]byte, error) {
+ switch t.T {
+ case IntTy, UintTy:
+ return packNum(reflectValue), nil
+ case StringTy:
+ return packBytesSlice([]byte(reflectValue.String()), reflectValue.Len()), nil
+ case AddressTy:
+ if reflectValue.Kind() == reflect.Array {
+ reflectValue = mustArrayToByteSlice(reflectValue)
+ }
+
+ return common.LeftPadBytes(reflectValue.Bytes(), 32), nil
+ case BoolTy:
+ if reflectValue.Bool() {
+ return math.PaddedBigBytes(common.Big1, 32), nil
+ }
+ return math.PaddedBigBytes(common.Big0, 32), nil
+ case BytesTy:
+ if reflectValue.Kind() == reflect.Array {
+ reflectValue = mustArrayToByteSlice(reflectValue)
+ }
+ if reflectValue.Type() != reflect.TypeOf([]byte{}) {
+ return []byte{}, errors.New("Bytes type is neither slice nor array")
+ }
+ return packBytesSlice(reflectValue.Bytes(), reflectValue.Len()), nil
+ case FixedBytesTy, FunctionTy:
+ if reflectValue.Kind() == reflect.Array {
+ reflectValue = mustArrayToByteSlice(reflectValue)
+ }
+ return common.RightPadBytes(reflectValue.Bytes(), 32), nil
+ default:
+ return []byte{}, fmt.Errorf("Could not pack element, unknown type: %v", t.T)
+ }
+}
+
+// packNum packs the given number (using the reflect value) and will cast it to appropriate number representation.
+func packNum(value reflect.Value) []byte {
+ switch kind := value.Kind(); kind {
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+ return math.U256Bytes(new(big.Int).SetUint64(value.Uint()))
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return math.U256Bytes(big.NewInt(value.Int()))
+ case reflect.Ptr:
+ return math.U256Bytes(new(big.Int).Set(value.Interface().(*big.Int)))
+ default:
+ panic("abi: fatal error")
+ }
+}
diff --git a/abigen/accounts/abi/pack_test.go b/abigen/accounts/abi/pack_test.go
new file mode 100644
index 00000000..5c7cb1cc
--- /dev/null
+++ b/abigen/accounts/abi/pack_test.go
@@ -0,0 +1,211 @@
+// Copyright 2017 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package abi
+
+import (
+ "bytes"
+ "encoding/hex"
+ "fmt"
+ "math"
+ "math/big"
+ "reflect"
+ "strconv"
+ "strings"
+ "testing"
+
+ "github.com/ethereum/go-ethereum/common"
+)
+
+// TestPack tests the general pack/unpack tests in packing_test.go
+func TestPack(t *testing.T) {
+ for i, test := range packUnpackTests {
+ t.Run(strconv.Itoa(i), func(t *testing.T) {
+ encb, err := hex.DecodeString(test.packed)
+ if err != nil {
+ t.Fatalf("invalid hex %s: %v", test.packed, err)
+ }
+ inDef := fmt.Sprintf(`[{ "name" : "method", "type": "function", "inputs": %s}]`, test.def)
+ inAbi, err := JSON(strings.NewReader(inDef))
+ if err != nil {
+ t.Fatalf("invalid ABI definition %s, %v", inDef, err)
+ }
+ var packed []byte
+ packed, err = inAbi.Pack("method", test.unpacked)
+
+ if err != nil {
+ t.Fatalf("test %d (%v) failed: %v", i, test.def, err)
+ }
+ if !reflect.DeepEqual(packed[4:], encb) {
+ t.Errorf("test %d (%v) failed: expected %v, got %v", i, test.def, encb, packed[4:])
+ }
+ })
+ }
+}
+
+func TestMethodPack(t *testing.T) {
+ abi, err := JSON(strings.NewReader(jsondata))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ sig := abi.Methods["slice"].ID
+ sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...)
+ sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...)
+
+ packed, err := abi.Pack("slice", []uint32{1, 2})
+ if err != nil {
+ t.Error(err)
+ }
+
+ if !bytes.Equal(packed, sig) {
+ t.Errorf("expected %x got %x", sig, packed)
+ }
+
+ var addrA, addrB = common.Address{1}, common.Address{2}
+ sig = abi.Methods["sliceAddress"].ID
+ sig = append(sig, common.LeftPadBytes([]byte{32}, 32)...)
+ sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...)
+ sig = append(sig, common.LeftPadBytes(addrA[:], 32)...)
+ sig = append(sig, common.LeftPadBytes(addrB[:], 32)...)
+
+ packed, err = abi.Pack("sliceAddress", []common.Address{addrA, addrB})
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !bytes.Equal(packed, sig) {
+ t.Errorf("expected %x got %x", sig, packed)
+ }
+
+ var addrC, addrD = common.Address{3}, common.Address{4}
+ sig = abi.Methods["sliceMultiAddress"].ID
+ sig = append(sig, common.LeftPadBytes([]byte{64}, 32)...)
+ sig = append(sig, common.LeftPadBytes([]byte{160}, 32)...)
+ sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...)
+ sig = append(sig, common.LeftPadBytes(addrA[:], 32)...)
+ sig = append(sig, common.LeftPadBytes(addrB[:], 32)...)
+ sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...)
+ sig = append(sig, common.LeftPadBytes(addrC[:], 32)...)
+ sig = append(sig, common.LeftPadBytes(addrD[:], 32)...)
+
+ packed, err = abi.Pack("sliceMultiAddress", []common.Address{addrA, addrB}, []common.Address{addrC, addrD})
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !bytes.Equal(packed, sig) {
+ t.Errorf("expected %x got %x", sig, packed)
+ }
+
+ sig = abi.Methods["slice256"].ID
+ sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...)
+ sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...)
+
+ packed, err = abi.Pack("slice256", []*big.Int{big.NewInt(1), big.NewInt(2)})
+ if err != nil {
+ t.Error(err)
+ }
+
+ if !bytes.Equal(packed, sig) {
+ t.Errorf("expected %x got %x", sig, packed)
+ }
+
+ a := [2][2]*big.Int{{big.NewInt(1), big.NewInt(1)}, {big.NewInt(2), big.NewInt(0)}}
+ sig = abi.Methods["nestedArray"].ID
+ sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...)
+ sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...)
+ sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...)
+ sig = append(sig, common.LeftPadBytes([]byte{0}, 32)...)
+ sig = append(sig, common.LeftPadBytes([]byte{0xa0}, 32)...)
+ sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...)
+ sig = append(sig, common.LeftPadBytes(addrC[:], 32)...)
+ sig = append(sig, common.LeftPadBytes(addrD[:], 32)...)
+ packed, err = abi.Pack("nestedArray", a, []common.Address{addrC, addrD})
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !bytes.Equal(packed, sig) {
+ t.Errorf("expected %x got %x", sig, packed)
+ }
+
+ sig = abi.Methods["nestedArray2"].ID
+ sig = append(sig, common.LeftPadBytes([]byte{0x20}, 32)...)
+ sig = append(sig, common.LeftPadBytes([]byte{0x40}, 32)...)
+ sig = append(sig, common.LeftPadBytes([]byte{0x80}, 32)...)
+ sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...)
+ sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...)
+ sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...)
+ sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...)
+ packed, err = abi.Pack("nestedArray2", [2][]uint8{{1}, {1}})
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !bytes.Equal(packed, sig) {
+ t.Errorf("expected %x got %x", sig, packed)
+ }
+
+ sig = abi.Methods["nestedSlice"].ID
+ sig = append(sig, common.LeftPadBytes([]byte{0x20}, 32)...)
+ sig = append(sig, common.LeftPadBytes([]byte{0x02}, 32)...)
+ sig = append(sig, common.LeftPadBytes([]byte{0x40}, 32)...)
+ sig = append(sig, common.LeftPadBytes([]byte{0xa0}, 32)...)
+ sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...)
+ sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...)
+ sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...)
+ sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...)
+ sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...)
+ sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...)
+ packed, err = abi.Pack("nestedSlice", [][]uint8{{1, 2}, {1, 2}})
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !bytes.Equal(packed, sig) {
+ t.Errorf("expected %x got %x", sig, packed)
+ }
+}
+
+func TestPackNumber(t *testing.T) {
+ tests := []struct {
+ value reflect.Value
+ packed []byte
+ }{
+ // Protocol limits
+ {reflect.ValueOf(0), common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000")},
+ {reflect.ValueOf(1), common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001")},
+ {reflect.ValueOf(-1), common.Hex2Bytes("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")},
+
+ // Type corner cases
+ {reflect.ValueOf(uint8(math.MaxUint8)), common.Hex2Bytes("00000000000000000000000000000000000000000000000000000000000000ff")},
+ {reflect.ValueOf(uint16(math.MaxUint16)), common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000ffff")},
+ {reflect.ValueOf(uint32(math.MaxUint32)), common.Hex2Bytes("00000000000000000000000000000000000000000000000000000000ffffffff")},
+ {reflect.ValueOf(uint64(math.MaxUint64)), common.Hex2Bytes("000000000000000000000000000000000000000000000000ffffffffffffffff")},
+
+ {reflect.ValueOf(int8(math.MaxInt8)), common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000007f")},
+ {reflect.ValueOf(int16(math.MaxInt16)), common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000007fff")},
+ {reflect.ValueOf(int32(math.MaxInt32)), common.Hex2Bytes("000000000000000000000000000000000000000000000000000000007fffffff")},
+ {reflect.ValueOf(int64(math.MaxInt64)), common.Hex2Bytes("0000000000000000000000000000000000000000000000007fffffffffffffff")},
+
+ {reflect.ValueOf(int8(math.MinInt8)), common.Hex2Bytes("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff80")},
+ {reflect.ValueOf(int16(math.MinInt16)), common.Hex2Bytes("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8000")},
+ {reflect.ValueOf(int32(math.MinInt32)), common.Hex2Bytes("ffffffffffffffffffffffffffffffffffffffffffffffffffffffff80000000")},
+ {reflect.ValueOf(int64(math.MinInt64)), common.Hex2Bytes("ffffffffffffffffffffffffffffffffffffffffffffffff8000000000000000")},
+ }
+ for i, tt := range tests {
+ packed := packNum(tt.value)
+ if !bytes.Equal(packed, tt.packed) {
+ t.Errorf("test %d: pack mismatch: have %x, want %x", i, packed, tt.packed)
+ }
+ }
+}
diff --git a/abigen/accounts/abi/packing_test.go b/abigen/accounts/abi/packing_test.go
new file mode 100644
index 00000000..eae3b0df
--- /dev/null
+++ b/abigen/accounts/abi/packing_test.go
@@ -0,0 +1,990 @@
+// Copyright 2020 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package abi
+
+import (
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/common"
+)
+
+type packUnpackTest struct {
+ def string
+ unpacked interface{}
+ packed string
+}
+
+var packUnpackTests = []packUnpackTest{
+ // Booleans
+ {
+ def: `[{ "type": "bool" }]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000001",
+ unpacked: true,
+ },
+ {
+ def: `[{ "type": "bool" }]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000000",
+ unpacked: false,
+ },
+ // Integers
+ {
+ def: `[{ "type": "uint8" }]`,
+ unpacked: uint8(2),
+ packed: "0000000000000000000000000000000000000000000000000000000000000002",
+ },
+ {
+ def: `[{ "type": "uint8[]" }]`,
+ unpacked: []uint8{1, 2},
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ },
+ {
+ def: `[{ "type": "uint16" }]`,
+ unpacked: uint16(2),
+ packed: "0000000000000000000000000000000000000000000000000000000000000002",
+ },
+ {
+ def: `[{ "type": "uint16[]" }]`,
+ unpacked: []uint16{1, 2},
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ },
+ {
+ def: `[{"type": "uint17"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000001",
+ unpacked: big.NewInt(1),
+ },
+ {
+ def: `[{"type": "uint32"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000001",
+ unpacked: uint32(1),
+ },
+ {
+ def: `[{"type": "uint32[]"}]`,
+ unpacked: []uint32{1, 2},
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ },
+ {
+ def: `[{"type": "uint64"}]`,
+ unpacked: uint64(2),
+ packed: "0000000000000000000000000000000000000000000000000000000000000002",
+ },
+ {
+ def: `[{"type": "uint64[]"}]`,
+ unpacked: []uint64{1, 2},
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ },
+ {
+ def: `[{"type": "uint256"}]`,
+ unpacked: big.NewInt(2),
+ packed: "0000000000000000000000000000000000000000000000000000000000000002",
+ },
+ {
+ def: `[{"type": "uint256[]"}]`,
+ unpacked: []*big.Int{big.NewInt(1), big.NewInt(2)},
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ },
+ {
+ def: `[{"type": "int8"}]`,
+ unpacked: int8(2),
+ packed: "0000000000000000000000000000000000000000000000000000000000000002",
+ },
+ {
+ def: `[{"type": "int8[]"}]`,
+ unpacked: []int8{1, 2},
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ },
+ {
+ def: `[{"type": "int16"}]`,
+ unpacked: int16(2),
+ packed: "0000000000000000000000000000000000000000000000000000000000000002",
+ },
+ {
+ def: `[{"type": "int16[]"}]`,
+ unpacked: []int16{1, 2},
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ },
+ {
+ def: `[{"type": "int17"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000001",
+ unpacked: big.NewInt(1),
+ },
+ {
+ def: `[{"type": "int32"}]`,
+ unpacked: int32(2),
+ packed: "0000000000000000000000000000000000000000000000000000000000000002",
+ },
+ {
+ def: `[{"type": "int32"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000001",
+ unpacked: int32(1),
+ },
+ {
+ def: `[{"type": "int32[]"}]`,
+ unpacked: []int32{1, 2},
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ },
+ {
+ def: `[{"type": "int64"}]`,
+ unpacked: int64(2),
+ packed: "0000000000000000000000000000000000000000000000000000000000000002",
+ },
+ {
+ def: `[{"type": "int64[]"}]`,
+ unpacked: []int64{1, 2},
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ },
+ {
+ def: `[{"type": "int256"}]`,
+ unpacked: big.NewInt(2),
+ packed: "0000000000000000000000000000000000000000000000000000000000000002",
+ },
+ {
+ def: `[{"type": "int256"}]`,
+ packed: "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+ unpacked: big.NewInt(-1),
+ },
+ {
+ def: `[{"type": "int256[]"}]`,
+ unpacked: []*big.Int{big.NewInt(1), big.NewInt(2)},
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ },
+ // Address
+ {
+ def: `[{"type": "address"}]`,
+ packed: "0000000000000000000000000100000000000000000000000000000000000000",
+ unpacked: common.Address{1},
+ },
+ {
+ def: `[{"type": "address[]"}]`,
+ unpacked: []common.Address{{1}, {2}},
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000100000000000000000000000000000000000000" +
+ "0000000000000000000000000200000000000000000000000000000000000000",
+ },
+ // Bytes
+ {
+ def: `[{"type": "bytes1"}]`,
+ unpacked: [1]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes2"}]`,
+ unpacked: [2]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes3"}]`,
+ unpacked: [3]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes4"}]`,
+ unpacked: [4]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes5"}]`,
+ unpacked: [5]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes6"}]`,
+ unpacked: [6]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes7"}]`,
+ unpacked: [7]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes8"}]`,
+ unpacked: [8]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes9"}]`,
+ unpacked: [9]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes10"}]`,
+ unpacked: [10]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes11"}]`,
+ unpacked: [11]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes12"}]`,
+ unpacked: [12]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes13"}]`,
+ unpacked: [13]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes14"}]`,
+ unpacked: [14]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes15"}]`,
+ unpacked: [15]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes16"}]`,
+ unpacked: [16]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes17"}]`,
+ unpacked: [17]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes18"}]`,
+ unpacked: [18]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes19"}]`,
+ unpacked: [19]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes20"}]`,
+ unpacked: [20]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes21"}]`,
+ unpacked: [21]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes22"}]`,
+ unpacked: [22]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes23"}]`,
+ unpacked: [23]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes24"}]`,
+ unpacked: [24]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes25"}]`,
+ unpacked: [25]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes26"}]`,
+ unpacked: [26]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes27"}]`,
+ unpacked: [27]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes28"}]`,
+ unpacked: [28]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes29"}]`,
+ unpacked: [29]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes30"}]`,
+ unpacked: [30]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes31"}]`,
+ unpacked: [31]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes32"}]`,
+ unpacked: [32]byte{1},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "bytes32"}]`,
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ unpacked: [32]byte{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ },
+ {
+ def: `[{"type": "bytes"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0100000000000000000000000000000000000000000000000000000000000000",
+ unpacked: common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
+ },
+ {
+ def: `[{"type": "bytes32"}]`,
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ unpacked: [32]byte{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ },
+ // Functions
+ {
+ def: `[{"type": "function"}]`,
+ packed: "0100000000000000000000000000000000000000000000000000000000000000",
+ unpacked: [24]byte{1},
+ },
+ // Slice and Array
+ {
+ def: `[{"type": "uint8[]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ unpacked: []uint8{1, 2},
+ },
+ {
+ def: `[{"type": "uint8[]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000000",
+ unpacked: []uint8{},
+ },
+ {
+ def: `[{"type": "uint256[]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000000",
+ unpacked: []*big.Int{},
+ },
+ {
+ def: `[{"type": "uint8[2]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ unpacked: [2]uint8{1, 2},
+ },
+ {
+ def: `[{"type": "int8[2]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ unpacked: [2]int8{1, 2},
+ },
+ {
+ def: `[{"type": "int16[]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ unpacked: []int16{1, 2},
+ },
+ {
+ def: `[{"type": "int16[2]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ unpacked: [2]int16{1, 2},
+ },
+ {
+ def: `[{"type": "int32[]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ unpacked: []int32{1, 2},
+ },
+ {
+ def: `[{"type": "int32[2]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ unpacked: [2]int32{1, 2},
+ },
+ {
+ def: `[{"type": "int64[]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ unpacked: []int64{1, 2},
+ },
+ {
+ def: `[{"type": "int64[2]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ unpacked: [2]int64{1, 2},
+ },
+ {
+ def: `[{"type": "int256[]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ unpacked: []*big.Int{big.NewInt(1), big.NewInt(2)},
+ },
+ {
+ def: `[{"type": "int256[3]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000003",
+ unpacked: [3]*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)},
+ },
+ // multi dimensional, if these pass, all types that don't require length prefix should pass
+ {
+ def: `[{"type": "uint8[][]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000000",
+ unpacked: [][]uint8{},
+ },
+ {
+ def: `[{"type": "uint8[][]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000040" +
+ "00000000000000000000000000000000000000000000000000000000000000a0" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ unpacked: [][]uint8{{1, 2}, {1, 2}},
+ },
+ {
+ def: `[{"type": "uint8[][]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000040" +
+ "00000000000000000000000000000000000000000000000000000000000000a0" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000003" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000003",
+ unpacked: [][]uint8{{1, 2}, {1, 2, 3}},
+ },
+ {
+ def: `[{"type": "uint8[2][2]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ unpacked: [2][2]uint8{{1, 2}, {1, 2}},
+ },
+ {
+ def: `[{"type": "uint8[][2]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000040" +
+ "0000000000000000000000000000000000000000000000000000000000000060" +
+ "0000000000000000000000000000000000000000000000000000000000000000" +
+ "0000000000000000000000000000000000000000000000000000000000000000",
+ unpacked: [2][]uint8{{}, {}},
+ },
+ {
+ def: `[{"type": "uint8[][2]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000040" +
+ "0000000000000000000000000000000000000000000000000000000000000080" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000001",
+ unpacked: [2][]uint8{{1}, {1}},
+ },
+ {
+ def: `[{"type": "uint8[2][]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000000",
+ unpacked: [][2]uint8{},
+ },
+ {
+ def: `[{"type": "uint8[2][]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ unpacked: [][2]uint8{{1, 2}},
+ },
+ {
+ def: `[{"type": "uint8[2][]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ unpacked: [][2]uint8{{1, 2}, {1, 2}},
+ },
+ {
+ def: `[{"type": "uint16[]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ unpacked: []uint16{1, 2},
+ },
+ {
+ def: `[{"type": "uint16[2]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ unpacked: [2]uint16{1, 2},
+ },
+ {
+ def: `[{"type": "uint32[]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ unpacked: []uint32{1, 2},
+ },
+ {
+ def: `[{"type": "uint32[2][3][4]"}]`,
+ unpacked: [4][3][2]uint32{{{1, 2}, {3, 4}, {5, 6}}, {{7, 8}, {9, 10}, {11, 12}}, {{13, 14}, {15, 16}, {17, 18}}, {{19, 20}, {21, 22}, {23, 24}}},
+ packed: "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000003" +
+ "0000000000000000000000000000000000000000000000000000000000000004" +
+ "0000000000000000000000000000000000000000000000000000000000000005" +
+ "0000000000000000000000000000000000000000000000000000000000000006" +
+ "0000000000000000000000000000000000000000000000000000000000000007" +
+ "0000000000000000000000000000000000000000000000000000000000000008" +
+ "0000000000000000000000000000000000000000000000000000000000000009" +
+ "000000000000000000000000000000000000000000000000000000000000000a" +
+ "000000000000000000000000000000000000000000000000000000000000000b" +
+ "000000000000000000000000000000000000000000000000000000000000000c" +
+ "000000000000000000000000000000000000000000000000000000000000000d" +
+ "000000000000000000000000000000000000000000000000000000000000000e" +
+ "000000000000000000000000000000000000000000000000000000000000000f" +
+ "0000000000000000000000000000000000000000000000000000000000000010" +
+ "0000000000000000000000000000000000000000000000000000000000000011" +
+ "0000000000000000000000000000000000000000000000000000000000000012" +
+ "0000000000000000000000000000000000000000000000000000000000000013" +
+ "0000000000000000000000000000000000000000000000000000000000000014" +
+ "0000000000000000000000000000000000000000000000000000000000000015" +
+ "0000000000000000000000000000000000000000000000000000000000000016" +
+ "0000000000000000000000000000000000000000000000000000000000000017" +
+ "0000000000000000000000000000000000000000000000000000000000000018",
+ },
+
+ {
+ def: `[{"type": "bytes32[]"}]`,
+ unpacked: [][32]byte{{1}, {2}},
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0100000000000000000000000000000000000000000000000000000000000000" +
+ "0200000000000000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "uint32[2]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ unpacked: [2]uint32{1, 2},
+ },
+ {
+ def: `[{"type": "uint64[]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ unpacked: []uint64{1, 2},
+ },
+ {
+ def: `[{"type": "uint64[2]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ unpacked: [2]uint64{1, 2},
+ },
+ {
+ def: `[{"type": "uint256[]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ unpacked: []*big.Int{big.NewInt(1), big.NewInt(2)},
+ },
+ {
+ def: `[{"type": "uint256[3]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000003",
+ unpacked: [3]*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)},
+ },
+ {
+ def: `[{"type": "string[4]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000080" +
+ "00000000000000000000000000000000000000000000000000000000000000c0" +
+ "0000000000000000000000000000000000000000000000000000000000000100" +
+ "0000000000000000000000000000000000000000000000000000000000000140" +
+ "0000000000000000000000000000000000000000000000000000000000000005" +
+ "48656c6c6f000000000000000000000000000000000000000000000000000000" +
+ "0000000000000000000000000000000000000000000000000000000000000005" +
+ "576f726c64000000000000000000000000000000000000000000000000000000" +
+ "000000000000000000000000000000000000000000000000000000000000000b" +
+ "476f2d657468657265756d000000000000000000000000000000000000000000" +
+ "0000000000000000000000000000000000000000000000000000000000000008" +
+ "457468657265756d000000000000000000000000000000000000000000000000",
+ unpacked: [4]string{"Hello", "World", "Go-ethereum", "Ethereum"},
+ },
+ {
+ def: `[{"type": "string[]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000040" +
+ "0000000000000000000000000000000000000000000000000000000000000080" +
+ "0000000000000000000000000000000000000000000000000000000000000008" +
+ "457468657265756d000000000000000000000000000000000000000000000000" +
+ "000000000000000000000000000000000000000000000000000000000000000b" +
+ "676f2d657468657265756d000000000000000000000000000000000000000000",
+ unpacked: []string{"Ethereum", "go-ethereum"},
+ },
+ {
+ def: `[{"type": "bytes[]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000040" +
+ "0000000000000000000000000000000000000000000000000000000000000080" +
+ "0000000000000000000000000000000000000000000000000000000000000003" +
+ "f0f0f00000000000000000000000000000000000000000000000000000000000" +
+ "0000000000000000000000000000000000000000000000000000000000000003" +
+ "f0f0f00000000000000000000000000000000000000000000000000000000000",
+ unpacked: [][]byte{{0xf0, 0xf0, 0xf0}, {0xf0, 0xf0, 0xf0}},
+ },
+ {
+ def: `[{"type": "uint256[2][][]"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000040" +
+ "00000000000000000000000000000000000000000000000000000000000000e0" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "00000000000000000000000000000000000000000000000000000000000000c8" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "00000000000000000000000000000000000000000000000000000000000003e8" +
+ "0000000000000000000000000000000000000000000000000000000000000002" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "00000000000000000000000000000000000000000000000000000000000000c8" +
+ "0000000000000000000000000000000000000000000000000000000000000001" +
+ "00000000000000000000000000000000000000000000000000000000000003e8",
+ unpacked: [][][2]*big.Int{{{big.NewInt(1), big.NewInt(200)}, {big.NewInt(1), big.NewInt(1000)}}, {{big.NewInt(1), big.NewInt(200)}, {big.NewInt(1), big.NewInt(1000)}}},
+ },
+ // struct outputs
+ {
+ def: `[{"components": [{"name":"int1","type":"int256"},{"name":"int2","type":"int256"}], "type":"tuple"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ unpacked: struct {
+ Int1 *big.Int
+ Int2 *big.Int
+ }{big.NewInt(1), big.NewInt(2)},
+ },
+ {
+ def: `[{"components": [{"name":"int_one","type":"int256"}], "type":"tuple"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000001",
+ unpacked: struct {
+ IntOne *big.Int
+ }{big.NewInt(1)},
+ },
+ {
+ def: `[{"components": [{"name":"int__one","type":"int256"}], "type":"tuple"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000001",
+ unpacked: struct {
+ IntOne *big.Int
+ }{big.NewInt(1)},
+ },
+ {
+ def: `[{"components": [{"name":"int_one_","type":"int256"}], "type":"tuple"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000001",
+ unpacked: struct {
+ IntOne *big.Int
+ }{big.NewInt(1)},
+ },
+ {
+ def: `[{"components": [{"name":"int_one","type":"int256"}, {"name":"intone","type":"int256"}], "type":"tuple"}]`,
+ packed: "0000000000000000000000000000000000000000000000000000000000000001" +
+ "0000000000000000000000000000000000000000000000000000000000000002",
+ unpacked: struct {
+ IntOne *big.Int
+ Intone *big.Int
+ }{big.NewInt(1), big.NewInt(2)},
+ },
+ {
+ def: `[{"type": "string"}]`,
+ unpacked: "foobar",
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000006" +
+ "666f6f6261720000000000000000000000000000000000000000000000000000",
+ },
+ {
+ def: `[{"type": "string[]"}]`,
+ unpacked: []string{"hello", "foobar"},
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" + // len(array) = 2
+ "0000000000000000000000000000000000000000000000000000000000000040" + // offset 64 to i = 0
+ "0000000000000000000000000000000000000000000000000000000000000080" + // offset 128 to i = 1
+ "0000000000000000000000000000000000000000000000000000000000000005" + // len(str[0]) = 5
+ "68656c6c6f000000000000000000000000000000000000000000000000000000" + // str[0]
+ "0000000000000000000000000000000000000000000000000000000000000006" + // len(str[1]) = 6
+ "666f6f6261720000000000000000000000000000000000000000000000000000", // str[1]
+ },
+ {
+ def: `[{"type": "string[2]"}]`,
+ unpacked: [2]string{"hello", "foobar"},
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000040" + // offset to i = 0
+ "0000000000000000000000000000000000000000000000000000000000000080" + // offset to i = 1
+ "0000000000000000000000000000000000000000000000000000000000000005" + // len(str[0]) = 5
+ "68656c6c6f000000000000000000000000000000000000000000000000000000" + // str[0]
+ "0000000000000000000000000000000000000000000000000000000000000006" + // len(str[1]) = 6
+ "666f6f6261720000000000000000000000000000000000000000000000000000", // str[1]
+ },
+ {
+ def: `[{"type": "bytes32[][]"}]`,
+ unpacked: [][][32]byte{{{1}, {2}}, {{3}, {4}, {5}}},
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" + // len(array) = 2
+ "0000000000000000000000000000000000000000000000000000000000000040" + // offset 64 to i = 0
+ "00000000000000000000000000000000000000000000000000000000000000a0" + // offset 160 to i = 1
+ "0000000000000000000000000000000000000000000000000000000000000002" + // len(array[0]) = 2
+ "0100000000000000000000000000000000000000000000000000000000000000" + // array[0][0]
+ "0200000000000000000000000000000000000000000000000000000000000000" + // array[0][1]
+ "0000000000000000000000000000000000000000000000000000000000000003" + // len(array[1]) = 3
+ "0300000000000000000000000000000000000000000000000000000000000000" + // array[1][0]
+ "0400000000000000000000000000000000000000000000000000000000000000" + // array[1][1]
+ "0500000000000000000000000000000000000000000000000000000000000000", // array[1][2]
+ },
+ {
+ def: `[{"type": "bytes32[][2]"}]`,
+ unpacked: [2][][32]byte{{{1}, {2}}, {{3}, {4}, {5}}},
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000040" + // offset 64 to i = 0
+ "00000000000000000000000000000000000000000000000000000000000000a0" + // offset 160 to i = 1
+ "0000000000000000000000000000000000000000000000000000000000000002" + // len(array[0]) = 2
+ "0100000000000000000000000000000000000000000000000000000000000000" + // array[0][0]
+ "0200000000000000000000000000000000000000000000000000000000000000" + // array[0][1]
+ "0000000000000000000000000000000000000000000000000000000000000003" + // len(array[1]) = 3
+ "0300000000000000000000000000000000000000000000000000000000000000" + // array[1][0]
+ "0400000000000000000000000000000000000000000000000000000000000000" + // array[1][1]
+ "0500000000000000000000000000000000000000000000000000000000000000", // array[1][2]
+ },
+ {
+ def: `[{"type": "bytes32[3][2]"}]`,
+ unpacked: [2][3][32]byte{{{1}, {2}, {3}}, {{3}, {4}, {5}}},
+ packed: "0100000000000000000000000000000000000000000000000000000000000000" + // array[0][0]
+ "0200000000000000000000000000000000000000000000000000000000000000" + // array[0][1]
+ "0300000000000000000000000000000000000000000000000000000000000000" + // array[0][2]
+ "0300000000000000000000000000000000000000000000000000000000000000" + // array[1][0]
+ "0400000000000000000000000000000000000000000000000000000000000000" + // array[1][1]
+ "0500000000000000000000000000000000000000000000000000000000000000", // array[1][2]
+ },
+ {
+ // static tuple
+ def: `[{"components": [{"name":"a","type":"int64"},
+ {"name":"b","type":"int256"},
+ {"name":"c","type":"int256"},
+ {"name":"d","type":"bool"},
+ {"name":"e","type":"bytes32[3][2]"}], "type":"tuple"}]`,
+ unpacked: struct {
+ A int64
+ B *big.Int
+ C *big.Int
+ D bool
+ E [2][3][32]byte
+ }{1, big.NewInt(1), big.NewInt(-1), true, [2][3][32]byte{{{1}, {2}, {3}}, {{3}, {4}, {5}}}},
+ packed: "0000000000000000000000000000000000000000000000000000000000000001" + // struct[a]
+ "0000000000000000000000000000000000000000000000000000000000000001" + // struct[b]
+ "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" + // struct[c]
+ "0000000000000000000000000000000000000000000000000000000000000001" + // struct[d]
+ "0100000000000000000000000000000000000000000000000000000000000000" + // struct[e] array[0][0]
+ "0200000000000000000000000000000000000000000000000000000000000000" + // struct[e] array[0][1]
+ "0300000000000000000000000000000000000000000000000000000000000000" + // struct[e] array[0][2]
+ "0300000000000000000000000000000000000000000000000000000000000000" + // struct[e] array[1][0]
+ "0400000000000000000000000000000000000000000000000000000000000000" + // struct[e] array[1][1]
+ "0500000000000000000000000000000000000000000000000000000000000000", // struct[e] array[1][2]
+ },
+ {
+ def: `[{"components": [{"name":"a","type":"string"},
+ {"name":"b","type":"int64"},
+ {"name":"c","type":"bytes"},
+ {"name":"d","type":"string[]"},
+ {"name":"e","type":"int256[]"},
+ {"name":"f","type":"address[]"}], "type":"tuple"}]`,
+ unpacked: struct {
+ A string
+ B int64
+ C []byte
+ D []string
+ E []*big.Int
+ F []common.Address
+ }{"foobar", 1, []byte{1}, []string{"foo", "bar"}, []*big.Int{big.NewInt(1), big.NewInt(-1)}, []common.Address{{1}, {2}}},
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" + // struct a
+ "00000000000000000000000000000000000000000000000000000000000000c0" + // struct[a] offset
+ "0000000000000000000000000000000000000000000000000000000000000001" + // struct[b]
+ "0000000000000000000000000000000000000000000000000000000000000100" + // struct[c] offset
+ "0000000000000000000000000000000000000000000000000000000000000140" + // struct[d] offset
+ "0000000000000000000000000000000000000000000000000000000000000220" + // struct[e] offset
+ "0000000000000000000000000000000000000000000000000000000000000280" + // struct[f] offset
+ "0000000000000000000000000000000000000000000000000000000000000006" + // struct[a] length
+ "666f6f6261720000000000000000000000000000000000000000000000000000" + // struct[a] "foobar"
+ "0000000000000000000000000000000000000000000000000000000000000001" + // struct[c] length
+ "0100000000000000000000000000000000000000000000000000000000000000" + // []byte{1}
+ "0000000000000000000000000000000000000000000000000000000000000002" + // struct[d] length
+ "0000000000000000000000000000000000000000000000000000000000000040" + // foo offset
+ "0000000000000000000000000000000000000000000000000000000000000080" + // bar offset
+ "0000000000000000000000000000000000000000000000000000000000000003" + // foo length
+ "666f6f0000000000000000000000000000000000000000000000000000000000" + // foo
+ "0000000000000000000000000000000000000000000000000000000000000003" + // bar offset
+ "6261720000000000000000000000000000000000000000000000000000000000" + // bar
+ "0000000000000000000000000000000000000000000000000000000000000002" + // struct[e] length
+ "0000000000000000000000000000000000000000000000000000000000000001" + // 1
+ "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" + // -1
+ "0000000000000000000000000000000000000000000000000000000000000002" + // struct[f] length
+ "0000000000000000000000000100000000000000000000000000000000000000" + // common.Address{1}
+ "0000000000000000000000000200000000000000000000000000000000000000", // common.Address{2}
+ },
+ {
+ def: `[{"components": [{ "type": "tuple","components": [{"name": "a","type": "uint256"},
+ {"name": "b","type": "uint256[]"}],
+ "name": "a","type": "tuple"},
+ {"name": "b","type": "uint256[]"}], "type": "tuple"}]`,
+ unpacked: struct {
+ A struct {
+ A *big.Int
+ B []*big.Int
+ }
+ B []*big.Int
+ }{
+ A: struct {
+ A *big.Int
+ B []*big.Int
+ }{big.NewInt(1), []*big.Int{big.NewInt(1), big.NewInt(2)}},
+ B: []*big.Int{big.NewInt(1), big.NewInt(2)}},
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" + // struct a
+ "0000000000000000000000000000000000000000000000000000000000000040" + // a offset
+ "00000000000000000000000000000000000000000000000000000000000000e0" + // b offset
+ "0000000000000000000000000000000000000000000000000000000000000001" + // a.a value
+ "0000000000000000000000000000000000000000000000000000000000000040" + // a.b offset
+ "0000000000000000000000000000000000000000000000000000000000000002" + // a.b length
+ "0000000000000000000000000000000000000000000000000000000000000001" + // a.b[0] value
+ "0000000000000000000000000000000000000000000000000000000000000002" + // a.b[1] value
+ "0000000000000000000000000000000000000000000000000000000000000002" + // b length
+ "0000000000000000000000000000000000000000000000000000000000000001" + // b[0] value
+ "0000000000000000000000000000000000000000000000000000000000000002", // b[1] value
+ },
+
+ {
+ def: `[{"components": [{"name": "a","type": "int256"},
+ {"name": "b","type": "int256[]"}],
+ "name": "a","type": "tuple[]"}]`,
+ unpacked: []struct {
+ A *big.Int
+ B []*big.Int
+ }{
+ {big.NewInt(-1), []*big.Int{big.NewInt(1), big.NewInt(3)}},
+ {big.NewInt(1), []*big.Int{big.NewInt(2), big.NewInt(-1)}},
+ },
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000002" + // tuple length
+ "0000000000000000000000000000000000000000000000000000000000000040" + // tuple[0] offset
+ "00000000000000000000000000000000000000000000000000000000000000e0" + // tuple[1] offset
+ "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" + // tuple[0].A
+ "0000000000000000000000000000000000000000000000000000000000000040" + // tuple[0].B offset
+ "0000000000000000000000000000000000000000000000000000000000000002" + // tuple[0].B length
+ "0000000000000000000000000000000000000000000000000000000000000001" + // tuple[0].B[0] value
+ "0000000000000000000000000000000000000000000000000000000000000003" + // tuple[0].B[1] value
+ "0000000000000000000000000000000000000000000000000000000000000001" + // tuple[1].A
+ "0000000000000000000000000000000000000000000000000000000000000040" + // tuple[1].B offset
+ "0000000000000000000000000000000000000000000000000000000000000002" + // tuple[1].B length
+ "0000000000000000000000000000000000000000000000000000000000000002" + // tuple[1].B[0] value
+ "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", // tuple[1].B[1] value
+ },
+ {
+ def: `[{"components": [{"name": "a","type": "int256"},
+ {"name": "b","type": "int256"}],
+ "name": "a","type": "tuple[2]"}]`,
+ unpacked: [2]struct {
+ A *big.Int
+ B *big.Int
+ }{
+ {big.NewInt(-1), big.NewInt(1)},
+ {big.NewInt(1), big.NewInt(-1)},
+ },
+ packed: "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" + // tuple[0].a
+ "0000000000000000000000000000000000000000000000000000000000000001" + // tuple[0].b
+ "0000000000000000000000000000000000000000000000000000000000000001" + // tuple[1].a
+ "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", // tuple[1].b
+ },
+ {
+ def: `[{"components": [{"name": "a","type": "int256[]"}],
+ "name": "a","type": "tuple[2]"}]`,
+ unpacked: [2]struct {
+ A []*big.Int
+ }{
+ {[]*big.Int{big.NewInt(-1), big.NewInt(1)}},
+ {[]*big.Int{big.NewInt(1), big.NewInt(-1)}},
+ },
+ packed: "0000000000000000000000000000000000000000000000000000000000000020" +
+ "0000000000000000000000000000000000000000000000000000000000000040" + // tuple[0] offset
+ "00000000000000000000000000000000000000000000000000000000000000c0" + // tuple[1] offset
+ "0000000000000000000000000000000000000000000000000000000000000020" + // tuple[0].A offset
+ "0000000000000000000000000000000000000000000000000000000000000002" + // tuple[0].A length
+ "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" + // tuple[0].A[0]
+ "0000000000000000000000000000000000000000000000000000000000000001" + // tuple[0].A[1]
+ "0000000000000000000000000000000000000000000000000000000000000020" + // tuple[1].A offset
+ "0000000000000000000000000000000000000000000000000000000000000002" + // tuple[1].A length
+ "0000000000000000000000000000000000000000000000000000000000000001" + // tuple[1].A[0]
+ "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", // tuple[1].A[1]
+ },
+}
diff --git a/abigen/accounts/abi/reflect.go b/abigen/accounts/abi/reflect.go
new file mode 100644
index 00000000..35e5556d
--- /dev/null
+++ b/abigen/accounts/abi/reflect.go
@@ -0,0 +1,260 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package abi
+
+import (
+ "errors"
+ "fmt"
+ "math/big"
+ "reflect"
+ "strings"
+)
+
+// ConvertType converts an interface of a runtime type into a interface of the
+// given type
+// e.g. turn
+// var fields []reflect.StructField
+// fields = append(fields, reflect.StructField{
+// Name: "X",
+// Type: reflect.TypeOf(new(big.Int)),
+// Tag: reflect.StructTag("json:\"" + "x" + "\""),
+// }
+// into
+// type TupleT struct { X *big.Int }
+func ConvertType(in interface{}, proto interface{}) interface{} {
+ protoType := reflect.TypeOf(proto)
+ if reflect.TypeOf(in).ConvertibleTo(protoType) {
+ return reflect.ValueOf(in).Convert(protoType).Interface()
+ }
+ // Use set as a last ditch effort
+ if err := set(reflect.ValueOf(proto), reflect.ValueOf(in)); err != nil {
+ panic(err)
+ }
+ return proto
+}
+
+// indirect recursively dereferences the value until it either gets the value
+// or finds a big.Int
+func indirect(v reflect.Value) reflect.Value {
+ if v.Kind() == reflect.Ptr && v.Elem().Type() != reflect.TypeOf(big.Int{}) {
+ return indirect(v.Elem())
+ }
+ return v
+}
+
+// reflectIntType returns the reflect using the given size and
+// unsignedness.
+func reflectIntType(unsigned bool, size int) reflect.Type {
+ if unsigned {
+ switch size {
+ case 8:
+ return reflect.TypeOf(uint8(0))
+ case 16:
+ return reflect.TypeOf(uint16(0))
+ case 32:
+ return reflect.TypeOf(uint32(0))
+ case 64:
+ return reflect.TypeOf(uint64(0))
+ }
+ }
+ switch size {
+ case 8:
+ return reflect.TypeOf(int8(0))
+ case 16:
+ return reflect.TypeOf(int16(0))
+ case 32:
+ return reflect.TypeOf(int32(0))
+ case 64:
+ return reflect.TypeOf(int64(0))
+ }
+ return reflect.TypeOf(&big.Int{})
+}
+
+// mustArrayToByteSlice creates a new byte slice with the exact same size as value
+// and copies the bytes in value to the new slice.
+func mustArrayToByteSlice(value reflect.Value) reflect.Value {
+ slice := reflect.MakeSlice(reflect.TypeOf([]byte{}), value.Len(), value.Len())
+ reflect.Copy(slice, value)
+ return slice
+}
+
+// set attempts to assign src to dst by either setting, copying or otherwise.
+//
+// set is a bit more lenient when it comes to assignment and doesn't force an as
+// strict ruleset as bare `reflect` does.
+func set(dst, src reflect.Value) error {
+ dstType, srcType := dst.Type(), src.Type()
+ switch {
+ case dstType.Kind() == reflect.Interface && dst.Elem().IsValid():
+ return set(dst.Elem(), src)
+ case dstType.Kind() == reflect.Ptr && dstType.Elem() != reflect.TypeOf(big.Int{}):
+ return set(dst.Elem(), src)
+ case srcType.AssignableTo(dstType) && dst.CanSet():
+ dst.Set(src)
+ case dstType.Kind() == reflect.Slice && srcType.Kind() == reflect.Slice && dst.CanSet():
+ return setSlice(dst, src)
+ case dstType.Kind() == reflect.Array:
+ return setArray(dst, src)
+ case dstType.Kind() == reflect.Struct:
+ return setStruct(dst, src)
+ default:
+ return fmt.Errorf("abi: cannot unmarshal %v in to %v", src.Type(), dst.Type())
+ }
+ return nil
+}
+
+// setSlice attempts to assign src to dst when slices are not assignable by default
+// e.g. src: [][]byte -> dst: [][15]byte
+// setSlice ignores if we cannot copy all of src' elements.
+func setSlice(dst, src reflect.Value) error {
+ slice := reflect.MakeSlice(dst.Type(), src.Len(), src.Len())
+ for i := 0; i < src.Len(); i++ {
+ if err := set(slice.Index(i), src.Index(i)); err != nil {
+ return err
+ }
+ }
+ if dst.CanSet() {
+ dst.Set(slice)
+ return nil
+ }
+ return errors.New("Cannot set slice, destination not settable")
+}
+
+func setArray(dst, src reflect.Value) error {
+ if src.Kind() == reflect.Ptr {
+ return set(dst, indirect(src))
+ }
+ array := reflect.New(dst.Type()).Elem()
+ min := src.Len()
+ if src.Len() > dst.Len() {
+ min = dst.Len()
+ }
+ for i := 0; i < min; i++ {
+ if err := set(array.Index(i), src.Index(i)); err != nil {
+ return err
+ }
+ }
+ if dst.CanSet() {
+ dst.Set(array)
+ return nil
+ }
+ return errors.New("Cannot set array, destination not settable")
+}
+
+func setStruct(dst, src reflect.Value) error {
+ for i := 0; i < src.NumField(); i++ {
+ srcField := src.Field(i)
+ dstField := dst.Field(i)
+ if !dstField.IsValid() || !srcField.IsValid() {
+ return fmt.Errorf("Could not find src field: %v value: %v in destination", srcField.Type().Name(), srcField)
+ }
+ if err := set(dstField, srcField); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+// mapArgNamesToStructFields maps a slice of argument names to struct fields.
+// first round: for each Exportable field that contains a `abi:""` tag
+// and this field name exists in the given argument name list, pair them together.
+// second round: for each argument name that has not been already linked,
+// find what variable is expected to be mapped into, if it exists and has not been
+// used, pair them.
+// Note this function assumes the given value is a struct value.
+func mapArgNamesToStructFields(argNames []string, value reflect.Value) (map[string]string, error) {
+ typ := value.Type()
+
+ abi2struct := make(map[string]string)
+ struct2abi := make(map[string]string)
+
+ // first round ~~~
+ for i := 0; i < typ.NumField(); i++ {
+ structFieldName := typ.Field(i).Name
+
+ // skip private struct fields.
+ if structFieldName[:1] != strings.ToUpper(structFieldName[:1]) {
+ continue
+ }
+ // skip fields that have no abi:"" tag.
+ tagName, ok := typ.Field(i).Tag.Lookup("abi")
+ if !ok {
+ continue
+ }
+ // check if tag is empty.
+ if tagName == "" {
+ return nil, fmt.Errorf("struct: abi tag in '%s' is empty", structFieldName)
+ }
+ // check which argument field matches with the abi tag.
+ found := false
+ for _, arg := range argNames {
+ if arg == tagName {
+ if abi2struct[arg] != "" {
+ return nil, fmt.Errorf("struct: abi tag in '%s' already mapped", structFieldName)
+ }
+ // pair them
+ abi2struct[arg] = structFieldName
+ struct2abi[structFieldName] = arg
+ found = true
+ }
+ }
+ // check if this tag has been mapped.
+ if !found {
+ return nil, fmt.Errorf("struct: abi tag '%s' defined but not found in abi", tagName)
+ }
+ }
+
+ // second round ~~~
+ for _, argName := range argNames {
+
+ structFieldName := ToCamelCase(argName)
+
+ if structFieldName == "" {
+ return nil, fmt.Errorf("abi: purely underscored output cannot unpack to struct")
+ }
+
+ // this abi has already been paired, skip it... unless there exists another, yet unassigned
+ // struct field with the same field name. If so, raise an error:
+ // abi: [ { "name": "value" } ]
+ // struct { Value *big.Int , Value1 *big.Int `abi:"value"`}
+ if abi2struct[argName] != "" {
+ if abi2struct[argName] != structFieldName &&
+ struct2abi[structFieldName] == "" &&
+ value.FieldByName(structFieldName).IsValid() {
+ return nil, fmt.Errorf("abi: multiple variables maps to the same abi field '%s'", argName)
+ }
+ continue
+ }
+
+ // return an error if this struct field has already been paired.
+ if struct2abi[structFieldName] != "" {
+ return nil, fmt.Errorf("abi: multiple outputs mapping to the same struct field '%s'", structFieldName)
+ }
+
+ if value.FieldByName(structFieldName).IsValid() {
+ // pair them
+ abi2struct[argName] = structFieldName
+ struct2abi[structFieldName] = argName
+ } else {
+ // not paired, but annotate as used, to detect cases like
+ // abi : [ { "name": "value" }, { "name": "_value" } ]
+ // struct { Value *big.Int }
+ struct2abi[structFieldName] = argName
+ }
+ }
+ return abi2struct, nil
+}
diff --git a/abigen/accounts/abi/reflect_test.go b/abigen/accounts/abi/reflect_test.go
new file mode 100644
index 00000000..cf13a79d
--- /dev/null
+++ b/abigen/accounts/abi/reflect_test.go
@@ -0,0 +1,261 @@
+// Copyright 2019 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package abi
+
+import (
+ "math/big"
+ "reflect"
+ "testing"
+)
+
+type reflectTest struct {
+ name string
+ args []string
+ struc interface{}
+ want map[string]string
+ err string
+}
+
+var reflectTests = []reflectTest{
+ {
+ name: "OneToOneCorrespondance",
+ args: []string{"fieldA"},
+ struc: struct {
+ FieldA int `abi:"fieldA"`
+ }{},
+ want: map[string]string{
+ "fieldA": "FieldA",
+ },
+ },
+ {
+ name: "MissingFieldsInStruct",
+ args: []string{"fieldA", "fieldB"},
+ struc: struct {
+ FieldA int `abi:"fieldA"`
+ }{},
+ want: map[string]string{
+ "fieldA": "FieldA",
+ },
+ },
+ {
+ name: "MoreFieldsInStructThanArgs",
+ args: []string{"fieldA"},
+ struc: struct {
+ FieldA int `abi:"fieldA"`
+ FieldB int
+ }{},
+ want: map[string]string{
+ "fieldA": "FieldA",
+ },
+ },
+ {
+ name: "MissingFieldInArgs",
+ args: []string{"fieldA"},
+ struc: struct {
+ FieldA int `abi:"fieldA"`
+ FieldB int `abi:"fieldB"`
+ }{},
+ err: "struct: abi tag 'fieldB' defined but not found in abi",
+ },
+ {
+ name: "NoAbiDescriptor",
+ args: []string{"fieldA"},
+ struc: struct {
+ FieldA int
+ }{},
+ want: map[string]string{
+ "fieldA": "FieldA",
+ },
+ },
+ {
+ name: "NoArgs",
+ args: []string{},
+ struc: struct {
+ FieldA int `abi:"fieldA"`
+ }{},
+ err: "struct: abi tag 'fieldA' defined but not found in abi",
+ },
+ {
+ name: "DifferentName",
+ args: []string{"fieldB"},
+ struc: struct {
+ FieldA int `abi:"fieldB"`
+ }{},
+ want: map[string]string{
+ "fieldB": "FieldA",
+ },
+ },
+ {
+ name: "DifferentName",
+ args: []string{"fieldB"},
+ struc: struct {
+ FieldA int `abi:"fieldB"`
+ }{},
+ want: map[string]string{
+ "fieldB": "FieldA",
+ },
+ },
+ {
+ name: "MultipleFields",
+ args: []string{"fieldA", "fieldB"},
+ struc: struct {
+ FieldA int `abi:"fieldA"`
+ FieldB int `abi:"fieldB"`
+ }{},
+ want: map[string]string{
+ "fieldA": "FieldA",
+ "fieldB": "FieldB",
+ },
+ },
+ {
+ name: "MultipleFieldsABIMissing",
+ args: []string{"fieldA", "fieldB"},
+ struc: struct {
+ FieldA int `abi:"fieldA"`
+ FieldB int
+ }{},
+ want: map[string]string{
+ "fieldA": "FieldA",
+ "fieldB": "FieldB",
+ },
+ },
+ {
+ name: "NameConflict",
+ args: []string{"fieldB"},
+ struc: struct {
+ FieldA int `abi:"fieldB"`
+ FieldB int
+ }{},
+ err: "abi: multiple variables maps to the same abi field 'fieldB'",
+ },
+ {
+ name: "Underscored",
+ args: []string{"_"},
+ struc: struct {
+ FieldA int
+ }{},
+ err: "abi: purely underscored output cannot unpack to struct",
+ },
+ {
+ name: "DoubleMapping",
+ args: []string{"fieldB", "fieldC", "fieldA"},
+ struc: struct {
+ FieldA int `abi:"fieldC"`
+ FieldB int
+ }{},
+ err: "abi: multiple outputs mapping to the same struct field 'FieldA'",
+ },
+ {
+ name: "AlreadyMapped",
+ args: []string{"fieldB", "fieldB"},
+ struc: struct {
+ FieldB int `abi:"fieldB"`
+ }{},
+ err: "struct: abi tag in 'FieldB' already mapped",
+ },
+}
+
+func TestReflectNameToStruct(t *testing.T) {
+ for _, test := range reflectTests {
+ t.Run(test.name, func(t *testing.T) {
+ m, err := mapArgNamesToStructFields(test.args, reflect.ValueOf(test.struc))
+ if len(test.err) > 0 {
+ if err == nil || err.Error() != test.err {
+ t.Fatalf("Invalid error: expected %v, got %v", test.err, err)
+ }
+ } else {
+ if err != nil {
+ t.Fatalf("Unexpected error: %v", err)
+ }
+ for fname := range test.want {
+ if m[fname] != test.want[fname] {
+ t.Fatalf("Incorrect value for field %s: expected %v, got %v", fname, test.want[fname], m[fname])
+ }
+ }
+ }
+ })
+ }
+}
+
+func TestConvertType(t *testing.T) {
+ // Test Basic Struct
+ type T struct {
+ X *big.Int
+ Y *big.Int
+ }
+ // Create on-the-fly structure
+ var fields []reflect.StructField
+ fields = append(fields, reflect.StructField{
+ Name: "X",
+ Type: reflect.TypeOf(new(big.Int)),
+ Tag: "json:\"" + "x" + "\"",
+ })
+ fields = append(fields, reflect.StructField{
+ Name: "Y",
+ Type: reflect.TypeOf(new(big.Int)),
+ Tag: "json:\"" + "y" + "\"",
+ })
+ val := reflect.New(reflect.StructOf(fields))
+ val.Elem().Field(0).Set(reflect.ValueOf(big.NewInt(1)))
+ val.Elem().Field(1).Set(reflect.ValueOf(big.NewInt(2)))
+ // ConvertType
+ out := *ConvertType(val.Interface(), new(T)).(*T)
+ if out.X.Cmp(big.NewInt(1)) != 0 {
+ t.Errorf("ConvertType failed, got %v want %v", out.X, big.NewInt(1))
+ }
+ if out.Y.Cmp(big.NewInt(2)) != 0 {
+ t.Errorf("ConvertType failed, got %v want %v", out.Y, big.NewInt(2))
+ }
+ // Slice Type
+ val2 := reflect.MakeSlice(reflect.SliceOf(reflect.StructOf(fields)), 2, 2)
+ val2.Index(0).Field(0).Set(reflect.ValueOf(big.NewInt(1)))
+ val2.Index(0).Field(1).Set(reflect.ValueOf(big.NewInt(2)))
+ val2.Index(1).Field(0).Set(reflect.ValueOf(big.NewInt(3)))
+ val2.Index(1).Field(1).Set(reflect.ValueOf(big.NewInt(4)))
+ out2 := *ConvertType(val2.Interface(), new([]T)).(*[]T)
+ if out2[0].X.Cmp(big.NewInt(1)) != 0 {
+ t.Errorf("ConvertType failed, got %v want %v", out2[0].X, big.NewInt(1))
+ }
+ if out2[0].Y.Cmp(big.NewInt(2)) != 0 {
+ t.Errorf("ConvertType failed, got %v want %v", out2[1].Y, big.NewInt(2))
+ }
+ if out2[1].X.Cmp(big.NewInt(3)) != 0 {
+ t.Errorf("ConvertType failed, got %v want %v", out2[0].X, big.NewInt(1))
+ }
+ if out2[1].Y.Cmp(big.NewInt(4)) != 0 {
+ t.Errorf("ConvertType failed, got %v want %v", out2[1].Y, big.NewInt(2))
+ }
+ // Array Type
+ val3 := reflect.New(reflect.ArrayOf(2, reflect.StructOf(fields)))
+ val3.Elem().Index(0).Field(0).Set(reflect.ValueOf(big.NewInt(1)))
+ val3.Elem().Index(0).Field(1).Set(reflect.ValueOf(big.NewInt(2)))
+ val3.Elem().Index(1).Field(0).Set(reflect.ValueOf(big.NewInt(3)))
+ val3.Elem().Index(1).Field(1).Set(reflect.ValueOf(big.NewInt(4)))
+ out3 := *ConvertType(val3.Interface(), new([2]T)).(*[2]T)
+ if out3[0].X.Cmp(big.NewInt(1)) != 0 {
+ t.Errorf("ConvertType failed, got %v want %v", out3[0].X, big.NewInt(1))
+ }
+ if out3[0].Y.Cmp(big.NewInt(2)) != 0 {
+ t.Errorf("ConvertType failed, got %v want %v", out3[1].Y, big.NewInt(2))
+ }
+ if out3[1].X.Cmp(big.NewInt(3)) != 0 {
+ t.Errorf("ConvertType failed, got %v want %v", out3[0].X, big.NewInt(1))
+ }
+ if out3[1].Y.Cmp(big.NewInt(4)) != 0 {
+ t.Errorf("ConvertType failed, got %v want %v", out3[1].Y, big.NewInt(2))
+ }
+}
diff --git a/abigen/accounts/abi/selector_parser.go b/abigen/accounts/abi/selector_parser.go
new file mode 100644
index 00000000..504f54bc
--- /dev/null
+++ b/abigen/accounts/abi/selector_parser.go
@@ -0,0 +1,176 @@
+// Copyright 2022 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package abi
+
+import (
+ "fmt"
+)
+
+type SelectorMarshaling struct {
+ Name string `json:"name"`
+ Type string `json:"type"`
+ Inputs []ArgumentMarshaling `json:"inputs"`
+}
+
+func isDigit(c byte) bool {
+ return c >= '0' && c <= '9'
+}
+
+func isAlpha(c byte) bool {
+ return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
+}
+
+func isIdentifierSymbol(c byte) bool {
+ return c == '$' || c == '_'
+}
+
+func parseToken(unescapedSelector string, isIdent bool) (string, string, error) {
+ if len(unescapedSelector) == 0 {
+ return "", "", fmt.Errorf("empty token")
+ }
+ firstChar := unescapedSelector[0]
+ position := 1
+ if !(isAlpha(firstChar) || (isIdent && isIdentifierSymbol(firstChar))) {
+ return "", "", fmt.Errorf("invalid token start: %c", firstChar)
+ }
+ for position < len(unescapedSelector) {
+ char := unescapedSelector[position]
+ if !(isAlpha(char) || isDigit(char) || (isIdent && isIdentifierSymbol(char))) {
+ break
+ }
+ position++
+ }
+ return unescapedSelector[:position], unescapedSelector[position:], nil
+}
+
+func parseIdentifier(unescapedSelector string) (string, string, error) {
+ return parseToken(unescapedSelector, true)
+}
+
+func parseElementaryType(unescapedSelector string) (string, string, error) {
+ parsedType, rest, err := parseToken(unescapedSelector, false)
+ if err != nil {
+ return "", "", fmt.Errorf("failed to parse elementary type: %v", err)
+ }
+ // handle arrays
+ for len(rest) > 0 && rest[0] == '[' {
+ parsedType = parsedType + string(rest[0])
+ rest = rest[1:]
+ for len(rest) > 0 && isDigit(rest[0]) {
+ parsedType = parsedType + string(rest[0])
+ rest = rest[1:]
+ }
+ if len(rest) == 0 || rest[0] != ']' {
+ return "", "", fmt.Errorf("failed to parse array: expected ']', got %c", unescapedSelector[0])
+ }
+ parsedType = parsedType + string(rest[0])
+ rest = rest[1:]
+ }
+ return parsedType, rest, nil
+}
+
+func parseCompositeType(unescapedSelector string) ([]interface{}, string, error) {
+ if len(unescapedSelector) == 0 || unescapedSelector[0] != '(' {
+ return nil, "", fmt.Errorf("expected '(', got %c", unescapedSelector[0])
+ }
+ parsedType, rest, err := parseType(unescapedSelector[1:])
+ if err != nil {
+ return nil, "", fmt.Errorf("failed to parse type: %v", err)
+ }
+ result := []interface{}{parsedType}
+ for len(rest) > 0 && rest[0] != ')' {
+ parsedType, rest, err = parseType(rest[1:])
+ if err != nil {
+ return nil, "", fmt.Errorf("failed to parse type: %v", err)
+ }
+ result = append(result, parsedType)
+ }
+ if len(rest) == 0 || rest[0] != ')' {
+ return nil, "", fmt.Errorf("expected ')', got '%s'", rest)
+ }
+ if len(rest) >= 3 && rest[1] == '[' && rest[2] == ']' {
+ return append(result, "[]"), rest[3:], nil
+ }
+ return result, rest[1:], nil
+}
+
+func parseType(unescapedSelector string) (interface{}, string, error) {
+ if len(unescapedSelector) == 0 {
+ return nil, "", fmt.Errorf("empty type")
+ }
+ if unescapedSelector[0] == '(' {
+ return parseCompositeType(unescapedSelector)
+ } else {
+ return parseElementaryType(unescapedSelector)
+ }
+}
+
+func assembleArgs(args []interface{}) ([]ArgumentMarshaling, error) {
+ arguments := make([]ArgumentMarshaling, 0)
+ for i, arg := range args {
+ // generate dummy name to avoid unmarshal issues
+ name := fmt.Sprintf("name%d", i)
+ if s, ok := arg.(string); ok {
+ arguments = append(arguments, ArgumentMarshaling{name, s, s, nil, false, 0})
+ } else if components, ok := arg.([]interface{}); ok {
+ subArgs, err := assembleArgs(components)
+ if err != nil {
+ return nil, fmt.Errorf("failed to assemble components: %v", err)
+ }
+ tupleType := "tuple"
+ if len(subArgs) != 0 && subArgs[len(subArgs)-1].Type == "[]" {
+ subArgs = subArgs[:len(subArgs)-1]
+ tupleType = "tuple[]"
+ }
+ arguments = append(arguments, ArgumentMarshaling{name, tupleType, tupleType, subArgs, false, 0})
+ } else {
+ return nil, fmt.Errorf("failed to assemble args: unexpected type %T", arg)
+ }
+ }
+ return arguments, nil
+}
+
+// ParseSelector converts a method selector into a struct that can be JSON encoded
+// and consumed by other functions in this package.
+// Note, although uppercase letters are not part of the ABI spec, this function
+// still accepts it as the general format is valid.
+func ParseSelector(unescapedSelector string) (SelectorMarshaling, error) {
+ name, rest, err := parseIdentifier(unescapedSelector)
+ if err != nil {
+ return SelectorMarshaling{}, fmt.Errorf("failed to parse selector '%s': %v", unescapedSelector, err)
+ }
+ args := []interface{}{}
+ if len(rest) >= 2 && rest[0] == '(' && rest[1] == ')' {
+ rest = rest[2:]
+ } else {
+ args, rest, err = parseCompositeType(rest)
+ if err != nil {
+ return SelectorMarshaling{}, fmt.Errorf("failed to parse selector '%s': %v", unescapedSelector, err)
+ }
+ }
+ if len(rest) > 0 {
+ return SelectorMarshaling{}, fmt.Errorf("failed to parse selector '%s': unexpected string '%s'", unescapedSelector, rest)
+ }
+
+ // Reassemble the fake ABI and constuct the JSON
+ fakeArgs, err := assembleArgs(args)
+ if err != nil {
+ return SelectorMarshaling{}, fmt.Errorf("failed to parse selector: %v", err)
+ }
+
+ return SelectorMarshaling{name, "function", fakeArgs}, nil
+}
diff --git a/abigen/accounts/abi/selector_parser_test.go b/abigen/accounts/abi/selector_parser_test.go
new file mode 100644
index 00000000..f6f13449
--- /dev/null
+++ b/abigen/accounts/abi/selector_parser_test.go
@@ -0,0 +1,79 @@
+// Copyright 2022 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package abi
+
+import (
+ "fmt"
+ "log"
+ "reflect"
+ "testing"
+)
+
+func TestParseSelector(t *testing.T) {
+ mkType := func(types ...interface{}) []ArgumentMarshaling {
+ var result []ArgumentMarshaling
+ for i, typeOrComponents := range types {
+ name := fmt.Sprintf("name%d", i)
+ if typeName, ok := typeOrComponents.(string); ok {
+ result = append(result, ArgumentMarshaling{name, typeName, typeName, nil, false})
+ } else if components, ok := typeOrComponents.([]ArgumentMarshaling); ok {
+ result = append(result, ArgumentMarshaling{name, "tuple", "tuple", components, false})
+ } else if components, ok := typeOrComponents.([][]ArgumentMarshaling); ok {
+ result = append(result, ArgumentMarshaling{name, "tuple[]", "tuple[]", components[0], false})
+ } else {
+ log.Fatalf("unexpected type %T", typeOrComponents)
+ }
+ }
+ return result
+ }
+ tests := []struct {
+ input string
+ name string
+ args []ArgumentMarshaling
+ }{
+ {"noargs()", "noargs", []ArgumentMarshaling{}},
+ {"simple(uint256,uint256,uint256)", "simple", mkType("uint256", "uint256", "uint256")},
+ {"other(uint256,address)", "other", mkType("uint256", "address")},
+ {"withArray(uint256[],address[2],uint8[4][][5])", "withArray", mkType("uint256[]", "address[2]", "uint8[4][][5]")},
+ {"singleNest(bytes32,uint8,(uint256,uint256),address)", "singleNest", mkType("bytes32", "uint8", mkType("uint256", "uint256"), "address")},
+ {"multiNest(address,(uint256[],uint256),((address,bytes32),uint256))", "multiNest",
+ mkType("address", mkType("uint256[]", "uint256"), mkType(mkType("address", "bytes32"), "uint256"))},
+ {"arrayNest((uint256,uint256)[],bytes32)", "arrayNest", mkType([][]ArgumentMarshaling{mkType("uint256", "uint256")}, "bytes32")},
+ {"multiArrayNest((uint256,uint256)[],(uint256,uint256)[])", "multiArrayNest",
+ mkType([][]ArgumentMarshaling{mkType("uint256", "uint256")}, [][]ArgumentMarshaling{mkType("uint256", "uint256")})},
+ {"singleArrayNestAndArray((uint256,uint256)[],bytes32[])", "singleArrayNestAndArray",
+ mkType([][]ArgumentMarshaling{mkType("uint256", "uint256")}, "bytes32[]")},
+ {"singleArrayNestWithArrayAndArray((uint256[],address[2],uint8[4][][5])[],bytes32[])", "singleArrayNestWithArrayAndArray",
+ mkType([][]ArgumentMarshaling{mkType("uint256[]", "address[2]", "uint8[4][][5]")}, "bytes32[]")},
+ }
+ for i, tt := range tests {
+ selector, err := ParseSelector(tt.input)
+ if err != nil {
+ t.Errorf("test %d: failed to parse selector '%v': %v", i, tt.input, err)
+ }
+ if selector.Name != tt.name {
+ t.Errorf("test %d: unexpected function name: '%s' != '%s'", i, selector.Name, tt.name)
+ }
+
+ if selector.Type != "function" {
+ t.Errorf("test %d: unexpected type: '%s' != '%s'", i, selector.Type, "function")
+ }
+ if !reflect.DeepEqual(selector.Inputs, tt.args) {
+ t.Errorf("test %d: unexpected args: '%v' != '%v'", i, selector.Inputs, tt.args)
+ }
+ }
+}
diff --git a/abigen/accounts/abi/topics.go b/abigen/accounts/abi/topics.go
new file mode 100644
index 00000000..360df7d5
--- /dev/null
+++ b/abigen/accounts/abi/topics.go
@@ -0,0 +1,173 @@
+// Copyright 2018 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package abi
+
+import (
+ "encoding/binary"
+ "errors"
+ "fmt"
+ "math/big"
+ "reflect"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/crypto"
+)
+
+// MakeTopics converts a filter query argument list into a filter topic set.
+func MakeTopics(query ...[]interface{}) ([][]common.Hash, error) {
+ topics := make([][]common.Hash, len(query))
+ for i, filter := range query {
+ for _, rule := range filter {
+ var topic common.Hash
+
+ // Try to generate the topic based on simple types
+ switch rule := rule.(type) {
+ case common.Hash:
+ copy(topic[:], rule[:])
+ case common.Address:
+ copy(topic[common.HashLength-common.AddressLength:], rule[:])
+ case *big.Int:
+ blob := rule.Bytes()
+ copy(topic[common.HashLength-len(blob):], blob)
+ case bool:
+ if rule {
+ topic[common.HashLength-1] = 1
+ }
+ case int8:
+ copy(topic[:], genIntType(int64(rule), 1))
+ case int16:
+ copy(topic[:], genIntType(int64(rule), 2))
+ case int32:
+ copy(topic[:], genIntType(int64(rule), 4))
+ case int64:
+ copy(topic[:], genIntType(rule, 8))
+ case uint8:
+ blob := new(big.Int).SetUint64(uint64(rule)).Bytes()
+ copy(topic[common.HashLength-len(blob):], blob)
+ case uint16:
+ blob := new(big.Int).SetUint64(uint64(rule)).Bytes()
+ copy(topic[common.HashLength-len(blob):], blob)
+ case uint32:
+ blob := new(big.Int).SetUint64(uint64(rule)).Bytes()
+ copy(topic[common.HashLength-len(blob):], blob)
+ case uint64:
+ blob := new(big.Int).SetUint64(rule).Bytes()
+ copy(topic[common.HashLength-len(blob):], blob)
+ case string:
+ hash := crypto.Keccak256Hash([]byte(rule))
+ copy(topic[:], hash[:])
+ case []byte:
+ hash := crypto.Keccak256Hash(rule)
+ copy(topic[:], hash[:])
+
+ default:
+ // todo(rjl493456442) according solidity documentation, indexed event
+ // parameters that are not value types i.e. arrays and structs are not
+ // stored directly but instead a keccak256-hash of an encoding is stored.
+ //
+ // We only convert stringS and bytes to hash, still need to deal with
+ // array(both fixed-size and dynamic-size) and struct.
+
+ // Attempt to generate the topic from funky types
+ val := reflect.ValueOf(rule)
+ switch {
+ // static byte array
+ case val.Kind() == reflect.Array && reflect.TypeOf(rule).Elem().Kind() == reflect.Uint8:
+ reflect.Copy(reflect.ValueOf(topic[:val.Len()]), val)
+ default:
+ return nil, fmt.Errorf("unsupported indexed type: %T", rule)
+ }
+ }
+ topics[i] = append(topics[i], topic)
+ }
+ }
+ return topics, nil
+}
+
+func genIntType(rule int64, size uint) []byte {
+ var topic [common.HashLength]byte
+ if rule < 0 {
+ // if a rule is negative, we need to put it into two's complement.
+ // extended to common.HashLength bytes.
+ topic = [common.HashLength]byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
+ }
+ for i := uint(0); i < size; i++ {
+ topic[common.HashLength-i-1] = byte(rule >> (i * 8))
+ }
+ return topic[:]
+}
+
+// ParseTopics converts the indexed topic fields into actual log field values.
+func ParseTopics(out interface{}, fields Arguments, topics []common.Hash) error {
+ return parseTopicWithSetter(fields, topics,
+ func(arg Argument, reconstr interface{}) {
+ field := reflect.ValueOf(out).Elem().FieldByName(ToCamelCase(arg.Name))
+ field.Set(reflect.ValueOf(reconstr))
+ })
+}
+
+// ParseTopicsIntoMap converts the indexed topic field-value pairs into map key-value pairs.
+func ParseTopicsIntoMap(out map[string]interface{}, fields Arguments, topics []common.Hash) error {
+ return parseTopicWithSetter(fields, topics,
+ func(arg Argument, reconstr interface{}) {
+ out[arg.Name] = reconstr
+ })
+}
+
+// parseTopicWithSetter converts the indexed topic field-value pairs and stores them using the
+// provided set function.
+//
+// Note, dynamic types cannot be reconstructed since they get mapped to Keccak256
+// hashes as the topic value!
+func parseTopicWithSetter(fields Arguments, topics []common.Hash, setter func(Argument, interface{})) error {
+ // Sanity check that the fields and topics match up
+ if len(fields) != len(topics) {
+ return errors.New("topic/field count mismatch")
+ }
+ // Iterate over all the fields and reconstruct them from topics
+ for i, arg := range fields {
+ if !arg.Indexed {
+ return errors.New("non-indexed field in topic reconstruction")
+ }
+ var reconstr interface{}
+ switch arg.Type.T {
+ case TupleTy:
+ return errors.New("tuple type in topic reconstruction")
+ case StringTy, BytesTy, SliceTy, ArrayTy:
+ // Array types (including strings and bytes) have their keccak256 hashes stored in the topic- not a hash
+ // whose bytes can be decoded to the actual value- so the best we can do is retrieve that hash
+ reconstr = topics[i]
+ case FunctionTy:
+ if garbage := binary.BigEndian.Uint64(topics[i][0:8]); garbage != 0 {
+ return fmt.Errorf("bind: got improperly encoded function type, got %v", topics[i].Bytes())
+ }
+ var tmp [24]byte
+ copy(tmp[:], topics[i][8:32])
+ reconstr = tmp
+ default:
+ var err error
+ reconstr, err = toGoType(0, arg.Type, topics[i].Bytes())
+ if err != nil {
+ return err
+ }
+ }
+ // Use the setter function to store the value
+ setter(arg, reconstr)
+ }
+
+ return nil
+}
diff --git a/abigen/accounts/abi/topics_test.go b/abigen/accounts/abi/topics_test.go
new file mode 100644
index 00000000..30cf21d0
--- /dev/null
+++ b/abigen/accounts/abi/topics_test.go
@@ -0,0 +1,381 @@
+// Copyright 2020 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package abi
+
+import (
+ "math/big"
+ "reflect"
+ "testing"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/crypto"
+)
+
+func TestMakeTopics(t *testing.T) {
+ type args struct {
+ query [][]interface{}
+ }
+ tests := []struct {
+ name string
+ args args
+ want [][]common.Hash
+ wantErr bool
+ }{
+ {
+ "support fixed byte types, right padded to 32 bytes",
+ args{[][]interface{}{{[5]byte{1, 2, 3, 4, 5}}}},
+ [][]common.Hash{{common.Hash{1, 2, 3, 4, 5}}},
+ false,
+ },
+ {
+ "support common hash types in topics",
+ args{[][]interface{}{{common.Hash{1, 2, 3, 4, 5}}}},
+ [][]common.Hash{{common.Hash{1, 2, 3, 4, 5}}},
+ false,
+ },
+ {
+ "support address types in topics",
+ args{[][]interface{}{{common.Address{1, 2, 3, 4, 5}}}},
+ [][]common.Hash{{common.Hash{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5}}},
+ false,
+ },
+ {
+ "support *big.Int types in topics",
+ args{[][]interface{}{{big.NewInt(1).Lsh(big.NewInt(2), 254)}}},
+ [][]common.Hash{{common.Hash{128}}},
+ false,
+ },
+ {
+ "support boolean types in topics",
+ args{[][]interface{}{
+ {true},
+ {false},
+ }},
+ [][]common.Hash{
+ {common.Hash{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}},
+ {common.Hash{0}},
+ },
+ false,
+ },
+ {
+ "support int/uint(8/16/32/64) types in topics",
+ args{[][]interface{}{
+ {int8(-2)},
+ {int16(-3)},
+ {int32(-4)},
+ {int64(-5)},
+ {int8(1)},
+ {int16(256)},
+ {int32(65536)},
+ {int64(4294967296)},
+ {uint8(1)},
+ {uint16(256)},
+ {uint32(65536)},
+ {uint64(4294967296)},
+ }},
+ [][]common.Hash{
+ {common.Hash{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 254}},
+ {common.Hash{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 253}},
+ {common.Hash{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 252}},
+ {common.Hash{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 251}},
+ {common.Hash{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}},
+ {common.Hash{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0}},
+ {common.Hash{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0}},
+ {common.Hash{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0}},
+ {common.Hash{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}},
+ {common.Hash{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0}},
+ {common.Hash{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0}},
+ {common.Hash{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0}},
+ },
+ false,
+ },
+ {
+ "support string types in topics",
+ args{[][]interface{}{{"hello world"}}},
+ [][]common.Hash{{crypto.Keccak256Hash([]byte("hello world"))}},
+ false,
+ },
+ {
+ "support byte slice types in topics",
+ args{[][]interface{}{{[]byte{1, 2, 3}}}},
+ [][]common.Hash{{crypto.Keccak256Hash([]byte{1, 2, 3})}},
+ false,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got, err := MakeTopics(tt.args.query...)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("makeTopics() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("makeTopics() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+type args struct {
+ createObj func() interface{}
+ resultObj func() interface{}
+ resultMap func() map[string]interface{}
+ fields Arguments
+ topics []common.Hash
+}
+
+type bytesStruct struct {
+ StaticBytes [5]byte
+}
+type int8Struct struct {
+ Int8Value int8
+}
+type int256Struct struct {
+ Int256Value *big.Int
+}
+
+type hashStruct struct {
+ HashValue common.Hash
+}
+
+type funcStruct struct {
+ FuncValue [24]byte
+}
+
+type topicTest struct {
+ name string
+ args args
+ wantErr bool
+}
+
+func setupTopicsTests() []topicTest {
+ bytesType, _ := NewType("bytes5", "", nil)
+ int8Type, _ := NewType("int8", "", nil)
+ int256Type, _ := NewType("int256", "", nil)
+ tupleType, _ := NewType("tuple(int256,int8)", "", nil)
+ stringType, _ := NewType("string", "", nil)
+ funcType, _ := NewType("function", "", nil)
+
+ tests := []topicTest{
+ {
+ name: "support fixed byte types, right padded to 32 bytes",
+ args: args{
+ createObj: func() interface{} { return &bytesStruct{} },
+ resultObj: func() interface{} { return &bytesStruct{StaticBytes: [5]byte{1, 2, 3, 4, 5}} },
+ resultMap: func() map[string]interface{} {
+ return map[string]interface{}{"staticBytes": [5]byte{1, 2, 3, 4, 5}}
+ },
+ fields: Arguments{Argument{
+ Name: "staticBytes",
+ Type: bytesType,
+ Indexed: true,
+ }},
+ topics: []common.Hash{
+ {1, 2, 3, 4, 5},
+ },
+ },
+ wantErr: false,
+ },
+ {
+ name: "int8 with negative value",
+ args: args{
+ createObj: func() interface{} { return &int8Struct{} },
+ resultObj: func() interface{} { return &int8Struct{Int8Value: -1} },
+ resultMap: func() map[string]interface{} {
+ return map[string]interface{}{"int8Value": int8(-1)}
+ },
+ fields: Arguments{Argument{
+ Name: "int8Value",
+ Type: int8Type,
+ Indexed: true,
+ }},
+ topics: []common.Hash{
+ {255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
+ },
+ },
+ wantErr: false,
+ },
+ {
+ name: "int256 with negative value",
+ args: args{
+ createObj: func() interface{} { return &int256Struct{} },
+ resultObj: func() interface{} { return &int256Struct{Int256Value: big.NewInt(-1)} },
+ resultMap: func() map[string]interface{} {
+ return map[string]interface{}{"int256Value": big.NewInt(-1)}
+ },
+ fields: Arguments{Argument{
+ Name: "int256Value",
+ Type: int256Type,
+ Indexed: true,
+ }},
+ topics: []common.Hash{
+ {255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
+ },
+ },
+ wantErr: false,
+ },
+ {
+ name: "hash type",
+ args: args{
+ createObj: func() interface{} { return &hashStruct{} },
+ resultObj: func() interface{} { return &hashStruct{crypto.Keccak256Hash([]byte("stringtopic"))} },
+ resultMap: func() map[string]interface{} {
+ return map[string]interface{}{"hashValue": crypto.Keccak256Hash([]byte("stringtopic"))}
+ },
+ fields: Arguments{Argument{
+ Name: "hashValue",
+ Type: stringType,
+ Indexed: true,
+ }},
+ topics: []common.Hash{
+ crypto.Keccak256Hash([]byte("stringtopic")),
+ },
+ },
+ wantErr: false,
+ },
+ {
+ name: "function type",
+ args: args{
+ createObj: func() interface{} { return &funcStruct{} },
+ resultObj: func() interface{} {
+ return &funcStruct{[24]byte{255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}
+ },
+ resultMap: func() map[string]interface{} {
+ return map[string]interface{}{"funcValue": [24]byte{255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}
+ },
+ fields: Arguments{Argument{
+ Name: "funcValue",
+ Type: funcType,
+ Indexed: true,
+ }},
+ topics: []common.Hash{
+ {0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
+ },
+ },
+ wantErr: false,
+ },
+ {
+ name: "error on topic/field count mismatch",
+ args: args{
+ createObj: func() interface{} { return nil },
+ resultObj: func() interface{} { return nil },
+ resultMap: func() map[string]interface{} { return make(map[string]interface{}) },
+ fields: Arguments{Argument{
+ Name: "tupletype",
+ Type: tupleType,
+ Indexed: true,
+ }},
+ topics: []common.Hash{},
+ },
+ wantErr: true,
+ },
+ {
+ name: "error on unindexed arguments",
+ args: args{
+ createObj: func() interface{} { return &int256Struct{} },
+ resultObj: func() interface{} { return &int256Struct{} },
+ resultMap: func() map[string]interface{} { return make(map[string]interface{}) },
+ fields: Arguments{Argument{
+ Name: "int256Value",
+ Type: int256Type,
+ Indexed: false,
+ }},
+ topics: []common.Hash{
+ {255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
+ },
+ },
+ wantErr: true,
+ },
+ {
+ name: "error on tuple in topic reconstruction",
+ args: args{
+ createObj: func() interface{} { return &tupleType },
+ resultObj: func() interface{} { return &tupleType },
+ resultMap: func() map[string]interface{} { return make(map[string]interface{}) },
+ fields: Arguments{Argument{
+ Name: "tupletype",
+ Type: tupleType,
+ Indexed: true,
+ }},
+ topics: []common.Hash{{0}},
+ },
+ wantErr: true,
+ },
+ {
+ name: "error on improper encoded function",
+ args: args{
+ createObj: func() interface{} { return &funcStruct{} },
+ resultObj: func() interface{} { return &funcStruct{} },
+ resultMap: func() map[string]interface{} {
+ return make(map[string]interface{})
+ },
+ fields: Arguments{Argument{
+ Name: "funcValue",
+ Type: funcType,
+ Indexed: true,
+ }},
+ topics: []common.Hash{
+ {0, 0, 0, 0, 0, 0, 0, 128, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
+ },
+ },
+ wantErr: true,
+ },
+ }
+
+ return tests
+}
+
+func TestParseTopics(t *testing.T) {
+ tests := setupTopicsTests()
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ createObj := tt.args.createObj()
+ if err := ParseTopics(createObj, tt.args.fields, tt.args.topics); (err != nil) != tt.wantErr {
+ t.Errorf("parseTopics() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ resultObj := tt.args.resultObj()
+ if !reflect.DeepEqual(createObj, resultObj) {
+ t.Errorf("parseTopics() = %v, want %v", createObj, resultObj)
+ }
+ })
+ }
+}
+
+func TestParseTopicsIntoMap(t *testing.T) {
+ tests := setupTopicsTests()
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ outMap := make(map[string]interface{})
+ if err := ParseTopicsIntoMap(outMap, tt.args.fields, tt.args.topics); (err != nil) != tt.wantErr {
+ t.Errorf("parseTopicsIntoMap() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ resultMap := tt.args.resultMap()
+ if !reflect.DeepEqual(outMap, resultMap) {
+ t.Errorf("parseTopicsIntoMap() = %v, want %v", outMap, resultMap)
+ }
+ })
+ }
+}
diff --git a/abigen/accounts/abi/type.go b/abigen/accounts/abi/type.go
new file mode 100644
index 00000000..05301399
--- /dev/null
+++ b/abigen/accounts/abi/type.go
@@ -0,0 +1,426 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package abi
+
+import (
+ "errors"
+ "fmt"
+ "reflect"
+ "regexp"
+ "strconv"
+ "strings"
+ "unicode"
+ "unicode/utf8"
+
+ "github.com/ethereum/go-ethereum/common"
+)
+
+// Type enumerator
+const (
+ IntTy byte = iota
+ UintTy
+ BoolTy
+ StringTy
+ SliceTy
+ ArrayTy
+ TupleTy
+ AddressTy
+ FixedBytesTy
+ BytesTy
+ HashTy
+ FixedPointTy
+ FunctionTy
+ StructTy
+)
+
+// Type is the reflection of the supported argument type.
+type Type struct {
+ Elem *Type
+ Size int
+ T byte // Our own type checking
+
+ stringKind string // holds the unparsed string for deriving signatures
+
+ // Tuple relative fields
+ TupleRawName string // Raw struct name defined in source code, may be empty.
+ TupleElems []*Type // Type information of all tuple fields
+ TupleRawNames []string // Raw field name of all tuple fields
+ TupleType reflect.Type // Underlying struct of the tuple
+}
+
+var (
+ // typeRegex parses the abi sub types
+ typeRegex = regexp.MustCompile("([a-zA-Z]+)(([0-9]+)(x([0-9]+))?)?")
+)
+
+// NewType creates a new reflection type of abi type given in t.
+func NewType(t string, internalType string, components []ArgumentMarshaling) (typ Type, err error) {
+ // check that array brackets are equal if they exist
+ if strings.Count(t, "[") != strings.Count(t, "]") {
+ return Type{}, fmt.Errorf("invalid arg type in abi")
+ }
+ typ.stringKind = t
+
+ // if there are brackets, get ready to go into slice/array mode and
+ // recursively create the type
+ if strings.Count(t, "[") != 0 {
+ // Note internalType can be empty here.
+ subInternal := internalType
+ if i := strings.LastIndex(internalType, "["); i != -1 {
+ subInternal = subInternal[:i]
+ }
+ // recursively embed the type
+ i := strings.LastIndex(t, "[")
+ embeddedType, err := NewType(t[:i], subInternal, components)
+ if err != nil {
+ return Type{}, err
+ }
+ // grab the last cell and create a type from there
+ sliced := t[i:]
+ // grab the slice size with regexp
+ re := regexp.MustCompile("[0-9]+")
+ intz := re.FindAllString(sliced, -1)
+
+ if len(intz) == 0 {
+ // is a slice
+ typ.T = SliceTy
+ typ.Elem = &embeddedType
+ typ.stringKind = embeddedType.stringKind + sliced
+ } else if len(intz) == 1 {
+ // is an array
+ typ.T = ArrayTy
+ typ.Elem = &embeddedType
+ typ.Size, err = strconv.Atoi(intz[0])
+ if err != nil {
+ return Type{}, fmt.Errorf("abi: error parsing variable size: %v", err)
+ }
+ typ.stringKind = embeddedType.stringKind + sliced
+ } else {
+ return Type{}, fmt.Errorf("invalid formatting of array type")
+ }
+ return typ, err
+ }
+ // parse the type and size of the abi-type.
+ matches := typeRegex.FindAllStringSubmatch(t, -1)
+ if len(matches) == 0 {
+ return Type{}, fmt.Errorf("invalid type '%v'", t)
+ }
+ parsedType := matches[0]
+
+ // varSize is the size of the variable
+ var varSize int
+ if len(parsedType[3]) > 0 {
+ var err error
+ varSize, err = strconv.Atoi(parsedType[2])
+ if err != nil {
+ return Type{}, fmt.Errorf("abi: error parsing variable size: %v", err)
+ }
+ } else {
+ if parsedType[0] == "uint" || parsedType[0] == "int" {
+ // this should fail because it means that there's something wrong with
+ // the abi type (the compiler should always format it to the size...always)
+ return Type{}, fmt.Errorf("unsupported arg type: %s", t)
+ }
+ }
+ // varType is the parsed abi type
+ switch varType := parsedType[1]; varType {
+ case "int":
+ typ.Size = varSize
+ typ.T = IntTy
+ case "uint":
+ typ.Size = varSize
+ typ.T = UintTy
+ case "bool":
+ typ.T = BoolTy
+ case "address":
+ typ.Size = 20
+ typ.T = AddressTy
+ case "string":
+ typ.T = StringTy
+ case "bytes":
+ if varSize == 0 {
+ typ.T = BytesTy
+ } else {
+ typ.T = FixedBytesTy
+ typ.Size = varSize
+ }
+ case "tuple":
+ var (
+ fields []reflect.StructField
+ elems []*Type
+ names []string
+ expression string // canonical parameter expression
+ used = make(map[string]bool)
+ )
+ expression += "("
+ for idx, c := range components {
+ cType, err := NewType(c.Type, c.InternalType, c.Components)
+ if err != nil {
+ return Type{}, err
+ }
+ name := ToCamelCase(c.Name)
+ if name == "" {
+ return Type{}, errors.New("abi: purely anonymous or underscored field is not supported")
+ }
+ fieldName := ResolveNameConflict(name, func(s string) bool { return used[s] })
+ if err != nil {
+ return Type{}, err
+ }
+ used[fieldName] = true
+ if !isValidFieldName(fieldName) {
+ return Type{}, fmt.Errorf("field %d has invalid name", idx)
+ }
+ fields = append(fields, reflect.StructField{
+ Name: fieldName, // reflect.StructOf will panic for any exported field.
+ Type: cType.GetType(),
+ Tag: reflect.StructTag("json:\"" + c.Name + "\""),
+ })
+ elems = append(elems, &cType)
+ names = append(names, c.Name)
+ expression += cType.stringKind
+ if idx != len(components)-1 {
+ expression += ","
+ }
+ }
+ expression += ")"
+
+ typ.TupleType = reflect.StructOf(fields)
+ typ.TupleElems = elems
+ typ.TupleRawNames = names
+ typ.T = TupleTy
+ typ.stringKind = expression
+
+ const structPrefix = "struct "
+ // After solidity 0.5.10, a new field of abi "internalType"
+ // is introduced. From that we can obtain the struct name
+ // user defined in the source code.
+ if internalType != "" && strings.HasPrefix(internalType, structPrefix) {
+ // Foo.Bar type definition is not allowed in golang,
+ // convert the format to FooBar
+ typ.TupleRawName = strings.ReplaceAll(internalType[len(structPrefix):], ".", "")
+ }
+
+ case "function":
+ typ.T = FunctionTy
+ typ.Size = 24
+ case "struct":
+ typ.T = StructTy
+ default:
+ return Type{}, fmt.Errorf("unsupported arg type: %s", t)
+ }
+
+ return
+}
+
+// GetType returns the reflection type of the ABI type.
+func (t Type) GetType() reflect.Type {
+ switch t.T {
+ case IntTy:
+ return reflectIntType(false, t.Size)
+ case UintTy:
+ return reflectIntType(true, t.Size)
+ case BoolTy:
+ return reflect.TypeOf(false)
+ case StringTy:
+ return reflect.TypeOf("")
+ case SliceTy:
+ return reflect.SliceOf(t.Elem.GetType())
+ case ArrayTy:
+ return reflect.ArrayOf(t.Size, t.Elem.GetType())
+ case TupleTy:
+ return t.TupleType
+ case AddressTy:
+ return reflect.TypeOf(common.Address{})
+ case FixedBytesTy:
+ return reflect.ArrayOf(t.Size, reflect.TypeOf(byte(0)))
+ case BytesTy:
+ return reflect.SliceOf(reflect.TypeOf(byte(0)))
+ case HashTy:
+ // hashtype currently not used
+ return reflect.ArrayOf(32, reflect.TypeOf(byte(0)))
+ case FixedPointTy:
+ // fixedpoint type currently not used
+ return reflect.ArrayOf(32, reflect.TypeOf(byte(0)))
+ case FunctionTy:
+ return reflect.ArrayOf(24, reflect.TypeOf(byte(0)))
+ default:
+ panic("Invalid type")
+ }
+}
+
+// String implements Stringer.
+func (t Type) String() (out string) {
+ return t.stringKind
+}
+
+func (t Type) pack(v reflect.Value) ([]byte, error) {
+ // dereference pointer first if it's a pointer
+ v = indirect(v)
+ if err := typeCheck(t, v); err != nil {
+ return nil, err
+ }
+
+ switch t.T {
+ case SliceTy, ArrayTy:
+ var ret []byte
+
+ if t.requiresLengthPrefix() {
+ // append length
+ ret = append(ret, packNum(reflect.ValueOf(v.Len()))...)
+ }
+
+ // calculate offset if any
+ offset := 0
+ offsetReq := isDynamicType(*t.Elem)
+ if offsetReq {
+ offset = getTypeSize(*t.Elem) * v.Len()
+ }
+ var tail []byte
+ for i := 0; i < v.Len(); i++ {
+ val, err := t.Elem.pack(v.Index(i))
+ if err != nil {
+ return nil, err
+ }
+ if !offsetReq {
+ ret = append(ret, val...)
+ continue
+ }
+ ret = append(ret, packNum(reflect.ValueOf(offset))...)
+ offset += len(val)
+ tail = append(tail, val...)
+ }
+ return append(ret, tail...), nil
+ case TupleTy:
+ // (T1,...,Tk) for k >= 0 and any types T1, …, Tk
+ // enc(X) = head(X(1)) ... head(X(k)) tail(X(1)) ... tail(X(k))
+ // where X = (X(1), ..., X(k)) and head and tail are defined for Ti being a static
+ // type as
+ // head(X(i)) = enc(X(i)) and tail(X(i)) = "" (the empty string)
+ // and as
+ // head(X(i)) = enc(len(head(X(1)) ... head(X(k)) tail(X(1)) ... tail(X(i-1))))
+ // tail(X(i)) = enc(X(i))
+ // otherwise, i.e. if Ti is a dynamic type.
+ fieldmap, err := mapArgNamesToStructFields(t.TupleRawNames, v)
+ if err != nil {
+ return nil, err
+ }
+ // Calculate prefix occupied size.
+ offset := 0
+ for _, elem := range t.TupleElems {
+ offset += getTypeSize(*elem)
+ }
+ var ret, tail []byte
+ for i, elem := range t.TupleElems {
+ field := v.FieldByName(fieldmap[t.TupleRawNames[i]])
+ if !field.IsValid() {
+ return nil, fmt.Errorf("field %s for tuple not found in the given struct", t.TupleRawNames[i])
+ }
+ val, err := elem.pack(field)
+ if err != nil {
+ return nil, err
+ }
+ if isDynamicType(*elem) {
+ ret = append(ret, packNum(reflect.ValueOf(offset))...)
+ tail = append(tail, val...)
+ offset += len(val)
+ } else {
+ ret = append(ret, val...)
+ }
+ }
+ return append(ret, tail...), nil
+
+ default:
+ return packElement(t, v)
+ }
+}
+
+// requireLengthPrefix returns whether the type requires any sort of length
+// prefixing.
+func (t Type) requiresLengthPrefix() bool {
+ return t.T == StringTy || t.T == BytesTy || t.T == SliceTy
+}
+
+// isDynamicType returns true if the type is dynamic.
+// The following types are called “dynamic”:
+// * bytes
+// * string
+// * T[] for any T
+// * T[k] for any dynamic T and any k >= 0
+// * (T1,...,Tk) if Ti is dynamic for some 1 <= i <= k
+func isDynamicType(t Type) bool {
+ if t.T == TupleTy {
+ for _, elem := range t.TupleElems {
+ if isDynamicType(*elem) {
+ return true
+ }
+ }
+ return false
+ }
+ return t.T == StringTy || t.T == BytesTy || t.T == SliceTy || (t.T == ArrayTy && isDynamicType(*t.Elem))
+}
+
+// getTypeSize returns the size that this type needs to occupy.
+// We distinguish static and dynamic types. Static types are encoded in-place
+// and dynamic types are encoded at a separately allocated location after the
+// current block.
+// So for a static variable, the size returned represents the size that the
+// variable actually occupies.
+// For a dynamic variable, the returned size is fixed 32 bytes, which is used
+// to store the location reference for actual value storage.
+func getTypeSize(t Type) int {
+ if t.T == ArrayTy && !isDynamicType(*t.Elem) {
+ // Recursively calculate type size if it is a nested array
+ if t.Elem.T == ArrayTy || t.Elem.T == TupleTy {
+ return t.Size * getTypeSize(*t.Elem)
+ }
+ return t.Size * 32
+ } else if t.T == TupleTy && !isDynamicType(t) {
+ total := 0
+ for _, elem := range t.TupleElems {
+ total += getTypeSize(*elem)
+ }
+ return total
+ }
+ return 32
+}
+
+// isLetter reports whether a given 'rune' is classified as a Letter.
+// This method is copied from reflect/type.go
+func isLetter(ch rune) bool {
+ return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_' || ch >= utf8.RuneSelf && unicode.IsLetter(ch)
+}
+
+// isValidFieldName checks if a string is a valid (struct) field name or not.
+//
+// According to the language spec, a field name should be an identifier.
+//
+// identifier = letter { letter | unicode_digit } .
+// letter = unicode_letter | "_" .
+// This method is copied from reflect/type.go
+func isValidFieldName(fieldName string) bool {
+ for i, c := range fieldName {
+ if i == 0 && !isLetter(c) {
+ return false
+ }
+
+ if !(isLetter(c) || unicode.IsDigit(c)) {
+ return false
+ }
+ }
+
+ return len(fieldName) > 0
+}
diff --git a/abigen/accounts/abi/type_test.go b/abigen/accounts/abi/type_test.go
new file mode 100644
index 00000000..8c3aedca
--- /dev/null
+++ b/abigen/accounts/abi/type_test.go
@@ -0,0 +1,368 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package abi
+
+import (
+ "math/big"
+ "reflect"
+ "testing"
+
+ "github.com/davecgh/go-spew/spew"
+ "github.com/ethereum/go-ethereum/common"
+)
+
+// typeWithoutStringer is a alias for the Type type which simply doesn't implement
+// the stringer interface to allow printing type details in the tests below.
+type typeWithoutStringer Type
+
+// Tests that all allowed types get recognized by the type parser.
+func TestTypeRegexp(t *testing.T) {
+ tests := []struct {
+ blob string
+ components []ArgumentMarshaling
+ kind Type
+ }{
+ {"bool", nil, Type{T: BoolTy, stringKind: "bool"}},
+ {"bool[]", nil, Type{T: SliceTy, Elem: &Type{T: BoolTy, stringKind: "bool"}, stringKind: "bool[]"}},
+ {"bool[2]", nil, Type{Size: 2, T: ArrayTy, Elem: &Type{T: BoolTy, stringKind: "bool"}, stringKind: "bool[2]"}},
+ {"bool[2][]", nil, Type{T: SliceTy, Elem: &Type{T: ArrayTy, Size: 2, Elem: &Type{T: BoolTy, stringKind: "bool"}, stringKind: "bool[2]"}, stringKind: "bool[2][]"}},
+ {"bool[][]", nil, Type{T: SliceTy, Elem: &Type{T: SliceTy, Elem: &Type{T: BoolTy, stringKind: "bool"}, stringKind: "bool[]"}, stringKind: "bool[][]"}},
+ {"bool[][2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{T: SliceTy, Elem: &Type{T: BoolTy, stringKind: "bool"}, stringKind: "bool[]"}, stringKind: "bool[][2]"}},
+ {"bool[2][2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{T: ArrayTy, Size: 2, Elem: &Type{T: BoolTy, stringKind: "bool"}, stringKind: "bool[2]"}, stringKind: "bool[2][2]"}},
+ {"bool[2][][2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{T: SliceTy, Elem: &Type{T: ArrayTy, Size: 2, Elem: &Type{T: BoolTy, stringKind: "bool"}, stringKind: "bool[2]"}, stringKind: "bool[2][]"}, stringKind: "bool[2][][2]"}},
+ {"bool[2][2][2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{T: ArrayTy, Size: 2, Elem: &Type{T: ArrayTy, Size: 2, Elem: &Type{T: BoolTy, stringKind: "bool"}, stringKind: "bool[2]"}, stringKind: "bool[2][2]"}, stringKind: "bool[2][2][2]"}},
+ {"bool[][][]", nil, Type{T: SliceTy, Elem: &Type{T: SliceTy, Elem: &Type{T: SliceTy, Elem: &Type{T: BoolTy, stringKind: "bool"}, stringKind: "bool[]"}, stringKind: "bool[][]"}, stringKind: "bool[][][]"}},
+ {"bool[][2][]", nil, Type{T: SliceTy, Elem: &Type{T: ArrayTy, Size: 2, Elem: &Type{T: SliceTy, Elem: &Type{T: BoolTy, stringKind: "bool"}, stringKind: "bool[]"}, stringKind: "bool[][2]"}, stringKind: "bool[][2][]"}},
+ {"int8", nil, Type{Size: 8, T: IntTy, stringKind: "int8"}},
+ {"int16", nil, Type{Size: 16, T: IntTy, stringKind: "int16"}},
+ {"int32", nil, Type{Size: 32, T: IntTy, stringKind: "int32"}},
+ {"int64", nil, Type{Size: 64, T: IntTy, stringKind: "int64"}},
+ {"int256", nil, Type{Size: 256, T: IntTy, stringKind: "int256"}},
+ {"int8[]", nil, Type{T: SliceTy, Elem: &Type{Size: 8, T: IntTy, stringKind: "int8"}, stringKind: "int8[]"}},
+ {"int8[2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{Size: 8, T: IntTy, stringKind: "int8"}, stringKind: "int8[2]"}},
+ {"int16[]", nil, Type{T: SliceTy, Elem: &Type{Size: 16, T: IntTy, stringKind: "int16"}, stringKind: "int16[]"}},
+ {"int16[2]", nil, Type{Size: 2, T: ArrayTy, Elem: &Type{Size: 16, T: IntTy, stringKind: "int16"}, stringKind: "int16[2]"}},
+ {"int32[]", nil, Type{T: SliceTy, Elem: &Type{Size: 32, T: IntTy, stringKind: "int32"}, stringKind: "int32[]"}},
+ {"int32[2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{Size: 32, T: IntTy, stringKind: "int32"}, stringKind: "int32[2]"}},
+ {"int64[]", nil, Type{T: SliceTy, Elem: &Type{Size: 64, T: IntTy, stringKind: "int64"}, stringKind: "int64[]"}},
+ {"int64[2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{Size: 64, T: IntTy, stringKind: "int64"}, stringKind: "int64[2]"}},
+ {"int256[]", nil, Type{T: SliceTy, Elem: &Type{Size: 256, T: IntTy, stringKind: "int256"}, stringKind: "int256[]"}},
+ {"int256[2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{Size: 256, T: IntTy, stringKind: "int256"}, stringKind: "int256[2]"}},
+ {"uint8", nil, Type{Size: 8, T: UintTy, stringKind: "uint8"}},
+ {"uint16", nil, Type{Size: 16, T: UintTy, stringKind: "uint16"}},
+ {"uint32", nil, Type{Size: 32, T: UintTy, stringKind: "uint32"}},
+ {"uint64", nil, Type{Size: 64, T: UintTy, stringKind: "uint64"}},
+ {"uint256", nil, Type{Size: 256, T: UintTy, stringKind: "uint256"}},
+ {"uint8[]", nil, Type{T: SliceTy, Elem: &Type{Size: 8, T: UintTy, stringKind: "uint8"}, stringKind: "uint8[]"}},
+ {"uint8[2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{Size: 8, T: UintTy, stringKind: "uint8"}, stringKind: "uint8[2]"}},
+ {"uint16[]", nil, Type{T: SliceTy, Elem: &Type{Size: 16, T: UintTy, stringKind: "uint16"}, stringKind: "uint16[]"}},
+ {"uint16[2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{Size: 16, T: UintTy, stringKind: "uint16"}, stringKind: "uint16[2]"}},
+ {"uint32[]", nil, Type{T: SliceTy, Elem: &Type{Size: 32, T: UintTy, stringKind: "uint32"}, stringKind: "uint32[]"}},
+ {"uint32[2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{Size: 32, T: UintTy, stringKind: "uint32"}, stringKind: "uint32[2]"}},
+ {"uint64[]", nil, Type{T: SliceTy, Elem: &Type{Size: 64, T: UintTy, stringKind: "uint64"}, stringKind: "uint64[]"}},
+ {"uint64[2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{Size: 64, T: UintTy, stringKind: "uint64"}, stringKind: "uint64[2]"}},
+ {"uint256[]", nil, Type{T: SliceTy, Elem: &Type{Size: 256, T: UintTy, stringKind: "uint256"}, stringKind: "uint256[]"}},
+ {"uint256[2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{Size: 256, T: UintTy, stringKind: "uint256"}, stringKind: "uint256[2]"}},
+ {"bytes32", nil, Type{T: FixedBytesTy, Size: 32, stringKind: "bytes32"}},
+ {"bytes[]", nil, Type{T: SliceTy, Elem: &Type{T: BytesTy, stringKind: "bytes"}, stringKind: "bytes[]"}},
+ {"bytes[2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{T: BytesTy, stringKind: "bytes"}, stringKind: "bytes[2]"}},
+ {"bytes32[]", nil, Type{T: SliceTy, Elem: &Type{T: FixedBytesTy, Size: 32, stringKind: "bytes32"}, stringKind: "bytes32[]"}},
+ {"bytes32[2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{T: FixedBytesTy, Size: 32, stringKind: "bytes32"}, stringKind: "bytes32[2]"}},
+ {"string", nil, Type{T: StringTy, stringKind: "string"}},
+ {"string[]", nil, Type{T: SliceTy, Elem: &Type{T: StringTy, stringKind: "string"}, stringKind: "string[]"}},
+ {"string[2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{T: StringTy, stringKind: "string"}, stringKind: "string[2]"}},
+ {"address", nil, Type{Size: 20, T: AddressTy, stringKind: "address"}},
+ {"address[]", nil, Type{T: SliceTy, Elem: &Type{Size: 20, T: AddressTy, stringKind: "address"}, stringKind: "address[]"}},
+ {"address[2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{Size: 20, T: AddressTy, stringKind: "address"}, stringKind: "address[2]"}},
+ // TODO when fixed types are implemented properly
+ // {"fixed", nil, Type{}},
+ // {"fixed128x128", nil, Type{}},
+ // {"fixed[]", nil, Type{}},
+ // {"fixed[2]", nil, Type{}},
+ // {"fixed128x128[]", nil, Type{}},
+ // {"fixed128x128[2]", nil, Type{}},
+ {"tuple", []ArgumentMarshaling{{Name: "a", Type: "int64"}}, Type{T: TupleTy, TupleType: reflect.TypeOf(struct {
+ A int64 `json:"a"`
+ }{}), stringKind: "(int64)",
+ TupleElems: []*Type{{T: IntTy, Size: 64, stringKind: "int64"}}, TupleRawNames: []string{"a"}}},
+ {"tuple with long name", []ArgumentMarshaling{{Name: "aTypicalParamName", Type: "int64"}}, Type{T: TupleTy, TupleType: reflect.TypeOf(struct {
+ ATypicalParamName int64 `json:"aTypicalParamName"`
+ }{}), stringKind: "(int64)",
+ TupleElems: []*Type{{T: IntTy, Size: 64, stringKind: "int64"}}, TupleRawNames: []string{"aTypicalParamName"}}},
+ }
+
+ for _, tt := range tests {
+ typ, err := NewType(tt.blob, "", tt.components)
+ if err != nil {
+ t.Errorf("type %q: failed to parse type string: %v", tt.blob, err)
+ }
+ if !reflect.DeepEqual(typ, tt.kind) {
+ t.Errorf("type %q: parsed type mismatch:\nGOT %s\nWANT %s ", tt.blob, spew.Sdump(typeWithoutStringer(typ)), spew.Sdump(typeWithoutStringer(tt.kind)))
+ }
+ }
+}
+
+func TestTypeCheck(t *testing.T) {
+ for i, test := range []struct {
+ typ string
+ components []ArgumentMarshaling
+ input interface{}
+ err string
+ }{
+ {"uint", nil, big.NewInt(1), "unsupported arg type: uint"},
+ {"int", nil, big.NewInt(1), "unsupported arg type: int"},
+ {"uint256", nil, big.NewInt(1), ""},
+ {"uint256[][3][]", nil, [][3][]*big.Int{{{}}}, ""},
+ {"uint256[][][3]", nil, [3][][]*big.Int{{{}}}, ""},
+ {"uint256[3][][]", nil, [][][3]*big.Int{{{}}}, ""},
+ {"uint256[3][3][3]", nil, [3][3][3]*big.Int{{{}}}, ""},
+ {"uint8[][]", nil, [][]uint8{}, ""},
+ {"int256", nil, big.NewInt(1), ""},
+ {"uint8", nil, uint8(1), ""},
+ {"uint16", nil, uint16(1), ""},
+ {"uint32", nil, uint32(1), ""},
+ {"uint64", nil, uint64(1), ""},
+ {"int8", nil, int8(1), ""},
+ {"int16", nil, int16(1), ""},
+ {"int32", nil, int32(1), ""},
+ {"int64", nil, int64(1), ""},
+ {"uint24", nil, big.NewInt(1), ""},
+ {"uint40", nil, big.NewInt(1), ""},
+ {"uint48", nil, big.NewInt(1), ""},
+ {"uint56", nil, big.NewInt(1), ""},
+ {"uint72", nil, big.NewInt(1), ""},
+ {"uint80", nil, big.NewInt(1), ""},
+ {"uint88", nil, big.NewInt(1), ""},
+ {"uint96", nil, big.NewInt(1), ""},
+ {"uint104", nil, big.NewInt(1), ""},
+ {"uint112", nil, big.NewInt(1), ""},
+ {"uint120", nil, big.NewInt(1), ""},
+ {"uint128", nil, big.NewInt(1), ""},
+ {"uint136", nil, big.NewInt(1), ""},
+ {"uint144", nil, big.NewInt(1), ""},
+ {"uint152", nil, big.NewInt(1), ""},
+ {"uint160", nil, big.NewInt(1), ""},
+ {"uint168", nil, big.NewInt(1), ""},
+ {"uint176", nil, big.NewInt(1), ""},
+ {"uint184", nil, big.NewInt(1), ""},
+ {"uint192", nil, big.NewInt(1), ""},
+ {"uint200", nil, big.NewInt(1), ""},
+ {"uint208", nil, big.NewInt(1), ""},
+ {"uint216", nil, big.NewInt(1), ""},
+ {"uint224", nil, big.NewInt(1), ""},
+ {"uint232", nil, big.NewInt(1), ""},
+ {"uint240", nil, big.NewInt(1), ""},
+ {"uint248", nil, big.NewInt(1), ""},
+ {"int24", nil, big.NewInt(1), ""},
+ {"int40", nil, big.NewInt(1), ""},
+ {"int48", nil, big.NewInt(1), ""},
+ {"int56", nil, big.NewInt(1), ""},
+ {"int72", nil, big.NewInt(1), ""},
+ {"int80", nil, big.NewInt(1), ""},
+ {"int88", nil, big.NewInt(1), ""},
+ {"int96", nil, big.NewInt(1), ""},
+ {"int104", nil, big.NewInt(1), ""},
+ {"int112", nil, big.NewInt(1), ""},
+ {"int120", nil, big.NewInt(1), ""},
+ {"int128", nil, big.NewInt(1), ""},
+ {"int136", nil, big.NewInt(1), ""},
+ {"int144", nil, big.NewInt(1), ""},
+ {"int152", nil, big.NewInt(1), ""},
+ {"int160", nil, big.NewInt(1), ""},
+ {"int168", nil, big.NewInt(1), ""},
+ {"int176", nil, big.NewInt(1), ""},
+ {"int184", nil, big.NewInt(1), ""},
+ {"int192", nil, big.NewInt(1), ""},
+ {"int200", nil, big.NewInt(1), ""},
+ {"int208", nil, big.NewInt(1), ""},
+ {"int216", nil, big.NewInt(1), ""},
+ {"int224", nil, big.NewInt(1), ""},
+ {"int232", nil, big.NewInt(1), ""},
+ {"int240", nil, big.NewInt(1), ""},
+ {"int248", nil, big.NewInt(1), ""},
+ {"uint30", nil, uint8(1), "abi: cannot use uint8 as type ptr as argument"},
+ {"uint8", nil, uint16(1), "abi: cannot use uint16 as type uint8 as argument"},
+ {"uint8", nil, uint32(1), "abi: cannot use uint32 as type uint8 as argument"},
+ {"uint8", nil, uint64(1), "abi: cannot use uint64 as type uint8 as argument"},
+ {"uint8", nil, int8(1), "abi: cannot use int8 as type uint8 as argument"},
+ {"uint8", nil, int16(1), "abi: cannot use int16 as type uint8 as argument"},
+ {"uint8", nil, int32(1), "abi: cannot use int32 as type uint8 as argument"},
+ {"uint8", nil, int64(1), "abi: cannot use int64 as type uint8 as argument"},
+ {"uint16", nil, uint16(1), ""},
+ {"uint16", nil, uint8(1), "abi: cannot use uint8 as type uint16 as argument"},
+ {"uint16[]", nil, []uint16{1, 2, 3}, ""},
+ {"uint16[]", nil, [3]uint16{1, 2, 3}, ""},
+ {"uint16[]", nil, []uint32{1, 2, 3}, "abi: cannot use []uint32 as type [0]uint16 as argument"},
+ {"uint16[3]", nil, [3]uint32{1, 2, 3}, "abi: cannot use [3]uint32 as type [3]uint16 as argument"},
+ {"uint16[3]", nil, [4]uint16{1, 2, 3}, "abi: cannot use [4]uint16 as type [3]uint16 as argument"},
+ {"uint16[3]", nil, []uint16{1, 2, 3}, ""},
+ {"uint16[3]", nil, []uint16{1, 2, 3, 4}, "abi: cannot use [4]uint16 as type [3]uint16 as argument"},
+ {"address[]", nil, []common.Address{{1}}, ""},
+ {"address[1]", nil, []common.Address{{1}}, ""},
+ {"address[1]", nil, [1]common.Address{{1}}, ""},
+ {"address[2]", nil, [1]common.Address{{1}}, "abi: cannot use [1]array as type [2]array as argument"},
+ {"bytes32", nil, [32]byte{}, ""},
+ {"bytes31", nil, [31]byte{}, ""},
+ {"bytes30", nil, [30]byte{}, ""},
+ {"bytes29", nil, [29]byte{}, ""},
+ {"bytes28", nil, [28]byte{}, ""},
+ {"bytes27", nil, [27]byte{}, ""},
+ {"bytes26", nil, [26]byte{}, ""},
+ {"bytes25", nil, [25]byte{}, ""},
+ {"bytes24", nil, [24]byte{}, ""},
+ {"bytes23", nil, [23]byte{}, ""},
+ {"bytes22", nil, [22]byte{}, ""},
+ {"bytes21", nil, [21]byte{}, ""},
+ {"bytes20", nil, [20]byte{}, ""},
+ {"bytes19", nil, [19]byte{}, ""},
+ {"bytes18", nil, [18]byte{}, ""},
+ {"bytes17", nil, [17]byte{}, ""},
+ {"bytes16", nil, [16]byte{}, ""},
+ {"bytes15", nil, [15]byte{}, ""},
+ {"bytes14", nil, [14]byte{}, ""},
+ {"bytes13", nil, [13]byte{}, ""},
+ {"bytes12", nil, [12]byte{}, ""},
+ {"bytes11", nil, [11]byte{}, ""},
+ {"bytes10", nil, [10]byte{}, ""},
+ {"bytes9", nil, [9]byte{}, ""},
+ {"bytes8", nil, [8]byte{}, ""},
+ {"bytes7", nil, [7]byte{}, ""},
+ {"bytes6", nil, [6]byte{}, ""},
+ {"bytes5", nil, [5]byte{}, ""},
+ {"bytes4", nil, [4]byte{}, ""},
+ {"bytes3", nil, [3]byte{}, ""},
+ {"bytes2", nil, [2]byte{}, ""},
+ {"bytes1", nil, [1]byte{}, ""},
+ {"bytes32", nil, [33]byte{}, "abi: cannot use [33]uint8 as type [32]uint8 as argument"},
+ {"bytes32", nil, common.Hash{1}, ""},
+ {"bytes31", nil, common.Hash{1}, "abi: cannot use common.Hash as type [31]uint8 as argument"},
+ {"bytes31", nil, [32]byte{}, "abi: cannot use [32]uint8 as type [31]uint8 as argument"},
+ {"bytes", nil, []byte{0, 1}, ""},
+ {"bytes", nil, [2]byte{0, 1}, "abi: cannot use array as type slice as argument"},
+ {"bytes", nil, common.Hash{1}, "abi: cannot use array as type slice as argument"},
+ {"string", nil, "hello world", ""},
+ {"string", nil, "", ""},
+ {"string", nil, []byte{}, "abi: cannot use slice as type string as argument"},
+ {"bytes32[]", nil, [][32]byte{{}}, ""},
+ {"function", nil, [24]byte{}, ""},
+ {"bytes20", nil, common.Address{}, ""},
+ {"address", nil, [20]byte{}, ""},
+ {"address", nil, common.Address{}, ""},
+ {"bytes32[]]", nil, "", "invalid arg type in abi"},
+ {"invalidType", nil, "", "unsupported arg type: invalidType"},
+ {"invalidSlice[]", nil, "", "unsupported arg type: invalidSlice"},
+ // simple tuple
+ {"tuple", []ArgumentMarshaling{{Name: "a", Type: "uint256"}, {Name: "b", Type: "uint256"}}, struct {
+ A *big.Int
+ B *big.Int
+ }{}, ""},
+ // tuple slice
+ {"tuple[]", []ArgumentMarshaling{{Name: "a", Type: "uint256"}, {Name: "b", Type: "uint256"}}, []struct {
+ A *big.Int
+ B *big.Int
+ }{}, ""},
+ // tuple array
+ {"tuple[2]", []ArgumentMarshaling{{Name: "a", Type: "uint256"}, {Name: "b", Type: "uint256"}}, []struct {
+ A *big.Int
+ B *big.Int
+ }{{big.NewInt(0), big.NewInt(0)}, {big.NewInt(0), big.NewInt(0)}}, ""},
+ } {
+ typ, err := NewType(test.typ, "", test.components)
+ if err != nil && len(test.err) == 0 {
+ t.Fatal("unexpected parse error:", err)
+ } else if err != nil && len(test.err) != 0 {
+ if err.Error() != test.err {
+ t.Errorf("%d failed. Expected err: '%v' got err: '%v'", i, test.err, err)
+ }
+ continue
+ }
+
+ err = typeCheck(typ, reflect.ValueOf(test.input))
+ if err != nil && len(test.err) == 0 {
+ t.Errorf("%d failed. Expected no err but got: %v", i, err)
+ continue
+ }
+ if err == nil && len(test.err) != 0 {
+ t.Errorf("%d failed. Expected err: %v but got none", i, test.err)
+ continue
+ }
+
+ if err != nil && len(test.err) != 0 && err.Error() != test.err {
+ t.Errorf("%d failed. Expected err: '%v' got err: '%v'", i, test.err, err)
+ }
+ }
+}
+
+func TestInternalType(t *testing.T) {
+ components := []ArgumentMarshaling{{Name: "a", Type: "int64"}}
+ internalType := "struct a.b[]"
+ kind := Type{
+ T: TupleTy,
+ TupleType: reflect.TypeOf(struct {
+ A int64 `json:"a"`
+ }{}),
+ stringKind: "(int64)",
+ TupleRawName: "ab[]",
+ TupleElems: []*Type{{T: IntTy, Size: 64, stringKind: "int64"}},
+ TupleRawNames: []string{"a"},
+ }
+
+ blob := "tuple"
+ typ, err := NewType(blob, internalType, components)
+ if err != nil {
+ t.Errorf("type %q: failed to parse type string: %v", blob, err)
+ }
+ if !reflect.DeepEqual(typ, kind) {
+ t.Errorf("type %q: parsed type mismatch:\nGOT %s\nWANT %s ", blob, spew.Sdump(typeWithoutStringer(typ)), spew.Sdump(typeWithoutStringer(kind)))
+ }
+}
+
+func TestGetTypeSize(t *testing.T) {
+ var testCases = []struct {
+ typ string
+ components []ArgumentMarshaling
+ typSize int
+ }{
+ // simple array
+ {"uint256[2]", nil, 32 * 2},
+ {"address[3]", nil, 32 * 3},
+ {"bytes32[4]", nil, 32 * 4},
+ // array array
+ {"uint256[2][3][4]", nil, 32 * (2 * 3 * 4)},
+ // array tuple
+ {"tuple[2]", []ArgumentMarshaling{{Name: "x", Type: "bytes32"}, {Name: "y", Type: "bytes32"}}, (32 * 2) * 2},
+ // simple tuple
+ {"tuple", []ArgumentMarshaling{{Name: "x", Type: "uint256"}, {Name: "y", Type: "uint256"}}, 32 * 2},
+ // tuple array
+ {"tuple", []ArgumentMarshaling{{Name: "x", Type: "bytes32[2]"}}, 32 * 2},
+ // tuple tuple
+ {"tuple", []ArgumentMarshaling{{Name: "x", Type: "tuple", Components: []ArgumentMarshaling{{Name: "x", Type: "bytes32"}}}}, 32},
+ {"tuple", []ArgumentMarshaling{{Name: "x", Type: "tuple", Components: []ArgumentMarshaling{{Name: "x", Type: "bytes32[2]"}, {Name: "y", Type: "uint256"}}}}, 32 * (2 + 1)},
+ }
+
+ for i, data := range testCases {
+ typ, err := NewType(data.typ, "", data.components)
+ if err != nil {
+ t.Errorf("type %q: failed to parse type string: %v", data.typ, err)
+ }
+
+ result := getTypeSize(typ)
+ if result != data.typSize {
+ t.Errorf("case %d type %q: get type size error: actual: %d expected: %d", i, data.typ, result, data.typSize)
+ }
+ }
+}
diff --git a/abigen/accounts/abi/unpack.go b/abigen/accounts/abi/unpack.go
new file mode 100644
index 00000000..28c5c82b
--- /dev/null
+++ b/abigen/accounts/abi/unpack.go
@@ -0,0 +1,298 @@
+// Copyright 2017 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package abi
+
+import (
+ "encoding/binary"
+ "fmt"
+ "math/big"
+ "reflect"
+
+ "github.com/ethereum/go-ethereum/common"
+)
+
+var (
+ // MaxUint256 is the maximum value that can be represented by a uint256.
+ MaxUint256 = new(big.Int).Sub(new(big.Int).Lsh(common.Big1, 256), common.Big1)
+ // MaxInt256 is the maximum value that can be represented by a int256.
+ MaxInt256 = new(big.Int).Sub(new(big.Int).Lsh(common.Big1, 255), common.Big1)
+)
+
+// ReadInteger reads the integer based on its kind and returns the appropriate value.
+func ReadInteger(typ Type, b []byte) interface{} {
+ if typ.T == UintTy {
+ switch typ.Size {
+ case 8:
+ return b[len(b)-1]
+ case 16:
+ return binary.BigEndian.Uint16(b[len(b)-2:])
+ case 32:
+ return binary.BigEndian.Uint32(b[len(b)-4:])
+ case 64:
+ return binary.BigEndian.Uint64(b[len(b)-8:])
+ default:
+ // the only case left for unsigned integer is uint256.
+ return new(big.Int).SetBytes(b)
+ }
+ }
+ switch typ.Size {
+ case 8:
+ return int8(b[len(b)-1])
+ case 16:
+ return int16(binary.BigEndian.Uint16(b[len(b)-2:]))
+ case 32:
+ return int32(binary.BigEndian.Uint32(b[len(b)-4:]))
+ case 64:
+ return int64(binary.BigEndian.Uint64(b[len(b)-8:]))
+ default:
+ // the only case left for integer is int256
+ // big.SetBytes can't tell if a number is negative or positive in itself.
+ // On EVM, if the returned number > max int256, it is negative.
+ // A number is > max int256 if the bit at position 255 is set.
+ ret := new(big.Int).SetBytes(b)
+ if ret.Bit(255) == 1 {
+ ret.Add(MaxUint256, new(big.Int).Neg(ret))
+ ret.Add(ret, common.Big1)
+ ret.Neg(ret)
+ }
+ return ret
+ }
+}
+
+// readBool reads a bool.
+func readBool(word []byte) (bool, error) {
+ for _, b := range word[:31] {
+ if b != 0 {
+ return false, errBadBool
+ }
+ }
+ switch word[31] {
+ case 0:
+ return false, nil
+ case 1:
+ return true, nil
+ default:
+ return false, errBadBool
+ }
+}
+
+// A function type is simply the address with the function selection signature at the end.
+//
+// readFunctionType enforces that standard by always presenting it as a 24-array (address + sig = 24 bytes)
+func readFunctionType(t Type, word []byte) (funcTy [24]byte, err error) {
+ if t.T != FunctionTy {
+ return [24]byte{}, fmt.Errorf("abi: invalid type in call to make function type byte array")
+ }
+ if garbage := binary.BigEndian.Uint64(word[24:32]); garbage != 0 {
+ err = fmt.Errorf("abi: got improperly encoded function type, got %v", word)
+ } else {
+ copy(funcTy[:], word[0:24])
+ }
+ return
+}
+
+// ReadFixedBytes uses reflection to create a fixed array to be read from.
+func ReadFixedBytes(t Type, word []byte) (interface{}, error) {
+ if t.T != FixedBytesTy {
+ return nil, fmt.Errorf("abi: invalid type in call to make fixed byte array")
+ }
+ // convert
+ array := reflect.New(t.GetType()).Elem()
+
+ reflect.Copy(array, reflect.ValueOf(word[0:t.Size]))
+ return array.Interface(), nil
+
+}
+
+// forEachUnpack iteratively unpack elements.
+func forEachUnpack(t Type, output []byte, start, size int) (interface{}, error) {
+ if size < 0 {
+ return nil, fmt.Errorf("cannot marshal input to array, size is negative (%d)", size)
+ }
+ if start+32*size > len(output) {
+ return nil, fmt.Errorf("abi: cannot marshal in to go array: offset %d would go over slice boundary (len=%d)", len(output), start+32*size)
+ }
+
+ // this value will become our slice or our array, depending on the type
+ var refSlice reflect.Value
+
+ if t.T == SliceTy {
+ // declare our slice
+ refSlice = reflect.MakeSlice(t.GetType(), size, size)
+ } else if t.T == ArrayTy {
+ // declare our array
+ refSlice = reflect.New(t.GetType()).Elem()
+ } else {
+ return nil, fmt.Errorf("abi: invalid type in array/slice unpacking stage")
+ }
+
+ // Arrays have packed elements, resulting in longer unpack steps.
+ // Slices have just 32 bytes per element (pointing to the contents).
+ elemSize := getTypeSize(*t.Elem)
+
+ for i, j := start, 0; j < size; i, j = i+elemSize, j+1 {
+ inter, err := toGoType(i, *t.Elem, output)
+ if err != nil {
+ return nil, err
+ }
+
+ // append the item to our reflect slice
+ refSlice.Index(j).Set(reflect.ValueOf(inter))
+ }
+
+ // return the interface
+ return refSlice.Interface(), nil
+}
+
+func forTupleUnpack(t Type, output []byte) (interface{}, error) {
+ retval := reflect.New(t.GetType()).Elem()
+ virtualArgs := 0
+ for index, elem := range t.TupleElems {
+ marshalledValue, err := toGoType((index+virtualArgs)*32, *elem, output)
+ if elem.T == ArrayTy && !isDynamicType(*elem) {
+ // If we have a static array, like [3]uint256, these are coded as
+ // just like uint256,uint256,uint256.
+ // This means that we need to add two 'virtual' arguments when
+ // we count the index from now on.
+ //
+ // Array values nested multiple levels deep are also encoded inline:
+ // [2][3]uint256: uint256,uint256,uint256,uint256,uint256,uint256
+ //
+ // Calculate the full array size to get the correct offset for the next argument.
+ // Decrement it by 1, as the normal index increment is still applied.
+ virtualArgs += getTypeSize(*elem)/32 - 1
+ } else if elem.T == TupleTy && !isDynamicType(*elem) {
+ // If we have a static tuple, like (uint256, bool, uint256), these are
+ // coded as just like uint256,bool,uint256
+ virtualArgs += getTypeSize(*elem)/32 - 1
+ }
+ if err != nil {
+ return nil, err
+ }
+ retval.Field(index).Set(reflect.ValueOf(marshalledValue))
+ }
+ return retval.Interface(), nil
+}
+
+// toGoType parses the output bytes and recursively assigns the value of these bytes
+// into a go type with accordance with the ABI spec.
+func toGoType(index int, t Type, output []byte) (interface{}, error) {
+ if index+32 > len(output) {
+ return nil, fmt.Errorf("abi: cannot marshal in to go type: length insufficient %d require %d", len(output), index+32)
+ }
+
+ var (
+ returnOutput []byte
+ begin, length int
+ err error
+ )
+
+ // if we require a length prefix, find the beginning word and size returned.
+ if t.requiresLengthPrefix() {
+ begin, length, err = lengthPrefixPointsTo(index, output)
+ if err != nil {
+ return nil, err
+ }
+ } else {
+ returnOutput = output[index : index+32]
+ }
+
+ switch t.T {
+ case TupleTy:
+ if isDynamicType(t) {
+ begin, err := tuplePointsTo(index, output)
+ if err != nil {
+ return nil, err
+ }
+ return forTupleUnpack(t, output[begin:])
+ }
+ return forTupleUnpack(t, output[index:])
+ case SliceTy:
+ return forEachUnpack(t, output[begin:], 0, length)
+ case ArrayTy:
+ if isDynamicType(*t.Elem) {
+ offset := binary.BigEndian.Uint64(returnOutput[len(returnOutput)-8:])
+ if offset > uint64(len(output)) {
+ return nil, fmt.Errorf("abi: toGoType offset greater than output length: offset: %d, len(output): %d", offset, len(output))
+ }
+ return forEachUnpack(t, output[offset:], 0, t.Size)
+ }
+ return forEachUnpack(t, output[index:], 0, t.Size)
+ case StringTy: // variable arrays are written at the end of the return bytes
+ return string(output[begin : begin+length]), nil
+ case IntTy, UintTy:
+ return ReadInteger(t, returnOutput), nil
+ case BoolTy:
+ return readBool(returnOutput)
+ case AddressTy:
+ return common.BytesToAddress(returnOutput), nil
+ case HashTy:
+ return common.BytesToHash(returnOutput), nil
+ case BytesTy:
+ return output[begin : begin+length], nil
+ case FixedBytesTy:
+ return ReadFixedBytes(t, returnOutput)
+ case FunctionTy:
+ return readFunctionType(t, returnOutput)
+ default:
+ return nil, fmt.Errorf("abi: unknown type %v", t.T)
+ }
+}
+
+// lengthPrefixPointsTo interprets a 32 byte slice as an offset and then determines which indices to look to decode the type.
+func lengthPrefixPointsTo(index int, output []byte) (start int, length int, err error) {
+ bigOffsetEnd := new(big.Int).SetBytes(output[index : index+32])
+ bigOffsetEnd.Add(bigOffsetEnd, common.Big32)
+ outputLength := big.NewInt(int64(len(output)))
+
+ if bigOffsetEnd.Cmp(outputLength) > 0 {
+ return 0, 0, fmt.Errorf("abi: cannot marshal in to go slice: offset %v would go over slice boundary (len=%v)", bigOffsetEnd, outputLength)
+ }
+
+ if bigOffsetEnd.BitLen() > 63 {
+ return 0, 0, fmt.Errorf("abi offset larger than int64: %v", bigOffsetEnd)
+ }
+
+ offsetEnd := int(bigOffsetEnd.Uint64())
+ lengthBig := new(big.Int).SetBytes(output[offsetEnd-32 : offsetEnd])
+
+ totalSize := new(big.Int).Add(bigOffsetEnd, lengthBig)
+ if totalSize.BitLen() > 63 {
+ return 0, 0, fmt.Errorf("abi: length larger than int64: %v", totalSize)
+ }
+
+ if totalSize.Cmp(outputLength) > 0 {
+ return 0, 0, fmt.Errorf("abi: cannot marshal in to go type: length insufficient %v require %v", outputLength, totalSize)
+ }
+ start = int(bigOffsetEnd.Uint64())
+ length = int(lengthBig.Uint64())
+ return
+}
+
+// tuplePointsTo resolves the location reference for dynamic tuple.
+func tuplePointsTo(index int, output []byte) (start int, err error) {
+ offset := new(big.Int).SetBytes(output[index : index+32])
+ outputLen := big.NewInt(int64(len(output)))
+
+ if offset.Cmp(outputLen) > 0 {
+ return 0, fmt.Errorf("abi: cannot marshal in to go slice: offset %v would go over slice boundary (len=%v)", offset, outputLen)
+ }
+ if offset.BitLen() > 63 {
+ return 0, fmt.Errorf("abi offset larger than int64: %v", offset)
+ }
+ return int(offset.Uint64()), nil
+}
diff --git a/abigen/accounts/abi/unpack_test.go b/abigen/accounts/abi/unpack_test.go
new file mode 100644
index 00000000..ae3565c7
--- /dev/null
+++ b/abigen/accounts/abi/unpack_test.go
@@ -0,0 +1,940 @@
+// Copyright 2017 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package abi
+
+import (
+ "bytes"
+ "encoding/hex"
+ "fmt"
+ "math/big"
+ "reflect"
+ "strconv"
+ "strings"
+ "testing"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/stretchr/testify/require"
+)
+
+// TestUnpack tests the general pack/unpack tests in packing_test.go
+func TestUnpack(t *testing.T) {
+ for i, test := range packUnpackTests {
+ t.Run(strconv.Itoa(i)+" "+test.def, func(t *testing.T) {
+ //Unpack
+ def := fmt.Sprintf(`[{ "name" : "method", "type": "function", "outputs": %s}]`, test.def)
+ abi, err := JSON(strings.NewReader(def))
+ if err != nil {
+ t.Fatalf("invalid ABI definition %s: %v", def, err)
+ }
+ encb, err := hex.DecodeString(test.packed)
+ if err != nil {
+ t.Fatalf("invalid hex %s: %v", test.packed, err)
+ }
+ out, err := abi.Unpack("method", encb)
+ if err != nil {
+ t.Errorf("test %d (%v) failed: %v", i, test.def, err)
+ return
+ }
+ if !reflect.DeepEqual(test.unpacked, ConvertType(out[0], test.unpacked)) {
+ t.Errorf("test %d (%v) failed: expected %v, got %v", i, test.def, test.unpacked, out[0])
+ }
+ })
+ }
+}
+
+type unpackTest struct {
+ def string // ABI definition JSON
+ enc string // evm return data
+ want interface{} // the expected output
+ err string // empty or error if expected
+}
+
+func (test unpackTest) checkError(err error) error {
+ if err != nil {
+ if len(test.err) == 0 {
+ return fmt.Errorf("expected no err but got: %v", err)
+ } else if err.Error() != test.err {
+ return fmt.Errorf("expected err: '%v' got err: %q", test.err, err)
+ }
+ } else if len(test.err) > 0 {
+ return fmt.Errorf("expected err: %v but got none", test.err)
+ }
+ return nil
+}
+
+var unpackTests = []unpackTest{
+ // Bools
+ {
+ def: `[{ "type": "bool" }]`,
+ enc: "0000000000000000000000000000000000000000000000000001000000000001",
+ want: false,
+ err: "abi: improperly encoded boolean value",
+ },
+ {
+ def: `[{ "type": "bool" }]`,
+ enc: "0000000000000000000000000000000000000000000000000000000000000003",
+ want: false,
+ err: "abi: improperly encoded boolean value",
+ },
+ // Integers
+ {
+ def: `[{"type": "uint32"}]`,
+ enc: "0000000000000000000000000000000000000000000000000000000000000001",
+ want: uint16(0),
+ err: "abi: cannot unmarshal uint32 in to uint16",
+ },
+ {
+ def: `[{"type": "uint17"}]`,
+ enc: "0000000000000000000000000000000000000000000000000000000000000001",
+ want: uint16(0),
+ err: "abi: cannot unmarshal *big.Int in to uint16",
+ },
+ {
+ def: `[{"type": "int32"}]`,
+ enc: "0000000000000000000000000000000000000000000000000000000000000001",
+ want: int16(0),
+ err: "abi: cannot unmarshal int32 in to int16",
+ },
+ {
+ def: `[{"type": "int17"}]`,
+ enc: "0000000000000000000000000000000000000000000000000000000000000001",
+ want: int16(0),
+ err: "abi: cannot unmarshal *big.Int in to int16",
+ },
+ {
+ def: `[{"type": "bytes"}]`,
+ enc: "000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200100000000000000000000000000000000000000000000000000000000000000",
+ want: [32]byte{1},
+ },
+ {
+ def: `[{"type": "bytes32"}]`,
+ enc: "000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200100000000000000000000000000000000000000000000000000000000000000",
+ want: []byte(nil),
+ err: "abi: cannot unmarshal [32]uint8 in to []uint8",
+ },
+ {
+ def: `[{"name":"___","type":"int256"}]`,
+ enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+ want: struct {
+ IntOne *big.Int
+ Intone *big.Int
+ }{IntOne: big.NewInt(1)},
+ },
+ {
+ def: `[{"name":"int_one","type":"int256"},{"name":"IntOne","type":"int256"}]`,
+ enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+ want: struct {
+ Int1 *big.Int
+ Int2 *big.Int
+ }{},
+ err: "abi: multiple outputs mapping to the same struct field 'IntOne'",
+ },
+ {
+ def: `[{"name":"int","type":"int256"},{"name":"Int","type":"int256"}]`,
+ enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+ want: struct {
+ Int1 *big.Int
+ Int2 *big.Int
+ }{},
+ err: "abi: multiple outputs mapping to the same struct field 'Int'",
+ },
+ {
+ def: `[{"name":"int","type":"int256"},{"name":"_int","type":"int256"}]`,
+ enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+ want: struct {
+ Int1 *big.Int
+ Int2 *big.Int
+ }{},
+ err: "abi: multiple outputs mapping to the same struct field 'Int'",
+ },
+ {
+ def: `[{"name":"Int","type":"int256"},{"name":"_int","type":"int256"}]`,
+ enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+ want: struct {
+ Int1 *big.Int
+ Int2 *big.Int
+ }{},
+ err: "abi: multiple outputs mapping to the same struct field 'Int'",
+ },
+ {
+ def: `[{"name":"Int","type":"int256"},{"name":"_","type":"int256"}]`,
+ enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+ want: struct {
+ Int1 *big.Int
+ Int2 *big.Int
+ }{},
+ err: "abi: purely underscored output cannot unpack to struct",
+ },
+ // Make sure only the first argument is consumed
+ {
+ def: `[{"name":"int_one","type":"int256"}]`,
+ enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+ want: struct {
+ IntOne *big.Int
+ }{big.NewInt(1)},
+ },
+ {
+ def: `[{"name":"int__one","type":"int256"}]`,
+ enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+ want: struct {
+ IntOne *big.Int
+ }{big.NewInt(1)},
+ },
+ {
+ def: `[{"name":"int_one_","type":"int256"}]`,
+ enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+ want: struct {
+ IntOne *big.Int
+ }{big.NewInt(1)},
+ },
+ {
+ def: `[{"type":"bool"}]`,
+ enc: "",
+ want: false,
+ err: "abi: attempting to unmarshall an empty string while arguments are expected",
+ },
+ {
+ def: `[{"type":"bytes32","indexed":true},{"type":"uint256","indexed":false}]`,
+ enc: "",
+ want: false,
+ err: "abi: attempting to unmarshall an empty string while arguments are expected",
+ },
+ {
+ def: `[{"type":"bool","indexed":true},{"type":"uint64","indexed":true}]`,
+ enc: "",
+ want: false,
+ },
+}
+
+// TestLocalUnpackTests runs test specially designed only for unpacking.
+// All test cases that can be used to test packing and unpacking should move to packing_test.go
+func TestLocalUnpackTests(t *testing.T) {
+ for i, test := range unpackTests {
+ t.Run(strconv.Itoa(i), func(t *testing.T) {
+ //Unpack
+ def := fmt.Sprintf(`[{ "name" : "method", "type": "function", "outputs": %s}]`, test.def)
+ abi, err := JSON(strings.NewReader(def))
+ if err != nil {
+ t.Fatalf("invalid ABI definition %s: %v", def, err)
+ }
+ encb, err := hex.DecodeString(test.enc)
+ if err != nil {
+ t.Fatalf("invalid hex %s: %v", test.enc, err)
+ }
+ outptr := reflect.New(reflect.TypeOf(test.want))
+ err = abi.UnpackIntoInterface(outptr.Interface(), "method", encb)
+ if err := test.checkError(err); err != nil {
+ t.Errorf("test %d (%v) failed: %v", i, test.def, err)
+ return
+ }
+ out := outptr.Elem().Interface()
+ if !reflect.DeepEqual(test.want, out) {
+ t.Errorf("test %d (%v) failed: expected %v, got %v", i, test.def, test.want, out)
+ }
+ })
+ }
+}
+
+func TestUnpackIntoInterfaceSetDynamicArrayOutput(t *testing.T) {
+ abi, err := JSON(strings.NewReader(`[{"constant":true,"inputs":[],"name":"testDynamicFixedBytes15","outputs":[{"name":"","type":"bytes15[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"testDynamicFixedBytes32","outputs":[{"name":"","type":"bytes32[]"}],"payable":false,"stateMutability":"view","type":"function"}]`))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ var (
+ marshalledReturn32 = common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000230783132333435363738393000000000000000000000000000000000000000003078303938373635343332310000000000000000000000000000000000000000")
+ marshalledReturn15 = common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000230783031323334350000000000000000000000000000000000000000000000003078393837363534000000000000000000000000000000000000000000000000")
+
+ out32 [][32]byte
+ out15 [][15]byte
+ )
+
+ // test 32
+ err = abi.UnpackIntoInterface(&out32, "testDynamicFixedBytes32", marshalledReturn32)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(out32) != 2 {
+ t.Fatalf("expected array with 2 values, got %d", len(out32))
+ }
+ expected := common.Hex2Bytes("3078313233343536373839300000000000000000000000000000000000000000")
+ if !bytes.Equal(out32[0][:], expected) {
+ t.Errorf("expected %x, got %x\n", expected, out32[0])
+ }
+ expected = common.Hex2Bytes("3078303938373635343332310000000000000000000000000000000000000000")
+ if !bytes.Equal(out32[1][:], expected) {
+ t.Errorf("expected %x, got %x\n", expected, out32[1])
+ }
+
+ // test 15
+ err = abi.UnpackIntoInterface(&out15, "testDynamicFixedBytes32", marshalledReturn15)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(out15) != 2 {
+ t.Fatalf("expected array with 2 values, got %d", len(out15))
+ }
+ expected = common.Hex2Bytes("307830313233343500000000000000")
+ if !bytes.Equal(out15[0][:], expected) {
+ t.Errorf("expected %x, got %x\n", expected, out15[0])
+ }
+ expected = common.Hex2Bytes("307839383736353400000000000000")
+ if !bytes.Equal(out15[1][:], expected) {
+ t.Errorf("expected %x, got %x\n", expected, out15[1])
+ }
+}
+
+type methodMultiOutput struct {
+ Int *big.Int
+ String string
+}
+
+func methodMultiReturn(require *require.Assertions) (ABI, []byte, methodMultiOutput) {
+ const definition = `[
+ { "name" : "multi", "type": "function", "outputs": [ { "name": "Int", "type": "uint256" }, { "name": "String", "type": "string" } ] }]`
+ var expected = methodMultiOutput{big.NewInt(1), "hello"}
+
+ abi, err := JSON(strings.NewReader(definition))
+ require.NoError(err)
+ // using buff to make the code readable
+ buff := new(bytes.Buffer)
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001"))
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000040"))
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000005"))
+ buff.Write(common.RightPadBytes([]byte(expected.String), 32))
+ return abi, buff.Bytes(), expected
+}
+
+func TestMethodMultiReturn(t *testing.T) {
+ type reversed struct {
+ String string
+ Int *big.Int
+ }
+
+ newInterfaceSlice := func(len int) interface{} {
+ slice := make([]interface{}, len)
+ return &slice
+ }
+
+ abi, data, expected := methodMultiReturn(require.New(t))
+ bigint := new(big.Int)
+ var testCases = []struct {
+ dest interface{}
+ expected interface{}
+ error string
+ name string
+ }{{
+ &methodMultiOutput{},
+ &expected,
+ "",
+ "Can unpack into structure",
+ }, {
+ &reversed{},
+ &reversed{expected.String, expected.Int},
+ "",
+ "Can unpack into reversed structure",
+ }, {
+ &[]interface{}{&bigint, new(string)},
+ &[]interface{}{&expected.Int, &expected.String},
+ "",
+ "Can unpack into a slice",
+ }, {
+ &[2]interface{}{&bigint, new(string)},
+ &[2]interface{}{&expected.Int, &expected.String},
+ "",
+ "Can unpack into an array",
+ }, {
+ &[2]interface{}{},
+ &[2]interface{}{expected.Int, expected.String},
+ "",
+ "Can unpack into interface array",
+ }, {
+ newInterfaceSlice(2),
+ &[]interface{}{expected.Int, expected.String},
+ "",
+ "Can unpack into interface slice",
+ }, {
+ &[]interface{}{new(int), new(int)},
+ &[]interface{}{&expected.Int, &expected.String},
+ "abi: cannot unmarshal *big.Int in to int",
+ "Can not unpack into a slice with wrong types",
+ }, {
+ &[]interface{}{new(int)},
+ &[]interface{}{},
+ "abi: insufficient number of arguments for unpack, want 2, got 1",
+ "Can not unpack into a slice with wrong types",
+ }}
+ for _, tc := range testCases {
+ tc := tc
+ t.Run(tc.name, func(t *testing.T) {
+ require := require.New(t)
+ err := abi.UnpackIntoInterface(tc.dest, "multi", data)
+ if tc.error == "" {
+ require.Nil(err, "Should be able to unpack method outputs.")
+ require.Equal(tc.expected, tc.dest)
+ } else {
+ require.EqualError(err, tc.error)
+ }
+ })
+ }
+}
+
+func TestMultiReturnWithArray(t *testing.T) {
+ const definition = `[{"name" : "multi", "type": "function", "outputs": [{"type": "uint64[3]"}, {"type": "uint64"}]}]`
+ abi, err := JSON(strings.NewReader(definition))
+ if err != nil {
+ t.Fatal(err)
+ }
+ buff := new(bytes.Buffer)
+ buff.Write(common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000900000000000000000000000000000000000000000000000000000000000000090000000000000000000000000000000000000000000000000000000000000009"))
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000008"))
+
+ ret1, ret1Exp := new([3]uint64), [3]uint64{9, 9, 9}
+ ret2, ret2Exp := new(uint64), uint64(8)
+ if err := abi.UnpackIntoInterface(&[]interface{}{ret1, ret2}, "multi", buff.Bytes()); err != nil {
+ t.Fatal(err)
+ }
+ if !reflect.DeepEqual(*ret1, ret1Exp) {
+ t.Error("array result", *ret1, "!= Expected", ret1Exp)
+ }
+ if *ret2 != ret2Exp {
+ t.Error("int result", *ret2, "!= Expected", ret2Exp)
+ }
+}
+
+func TestMultiReturnWithStringArray(t *testing.T) {
+ const definition = `[{"name" : "multi", "type": "function", "outputs": [{"name": "","type": "uint256[3]"},{"name": "","type": "address"},{"name": "","type": "string[2]"},{"name": "","type": "bool"}]}]`
+ abi, err := JSON(strings.NewReader(definition))
+ if err != nil {
+ t.Fatal(err)
+ }
+ buff := new(bytes.Buffer)
+ buff.Write(common.Hex2Bytes("000000000000000000000000000000000000000000000000000000005c1b78ea0000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000001a055690d9db80000000000000000000000000000ab1257528b3782fb40d7ed5f72e624b744dffb2f00000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000008457468657265756d000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001048656c6c6f2c20457468657265756d2100000000000000000000000000000000"))
+ temp, _ := new(big.Int).SetString("30000000000000000000", 10)
+ ret1, ret1Exp := new([3]*big.Int), [3]*big.Int{big.NewInt(1545304298), big.NewInt(6), temp}
+ ret2, ret2Exp := new(common.Address), common.HexToAddress("ab1257528b3782fb40d7ed5f72e624b744dffb2f")
+ ret3, ret3Exp := new([2]string), [2]string{"Ethereum", "Hello, Ethereum!"}
+ ret4, ret4Exp := new(bool), false
+ if err := abi.UnpackIntoInterface(&[]interface{}{ret1, ret2, ret3, ret4}, "multi", buff.Bytes()); err != nil {
+ t.Fatal(err)
+ }
+ if !reflect.DeepEqual(*ret1, ret1Exp) {
+ t.Error("big.Int array result", *ret1, "!= Expected", ret1Exp)
+ }
+ if !reflect.DeepEqual(*ret2, ret2Exp) {
+ t.Error("address result", *ret2, "!= Expected", ret2Exp)
+ }
+ if !reflect.DeepEqual(*ret3, ret3Exp) {
+ t.Error("string array result", *ret3, "!= Expected", ret3Exp)
+ }
+ if !reflect.DeepEqual(*ret4, ret4Exp) {
+ t.Error("bool result", *ret4, "!= Expected", ret4Exp)
+ }
+}
+
+func TestMultiReturnWithStringSlice(t *testing.T) {
+ const definition = `[{"name" : "multi", "type": "function", "outputs": [{"name": "","type": "string[]"},{"name": "","type": "uint256[]"}]}]`
+ abi, err := JSON(strings.NewReader(definition))
+ if err != nil {
+ t.Fatal(err)
+ }
+ buff := new(bytes.Buffer)
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000040")) // output[0] offset
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000120")) // output[1] offset
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002")) // output[0] length
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000040")) // output[0][0] offset
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000080")) // output[0][1] offset
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000008")) // output[0][0] length
+ buff.Write(common.Hex2Bytes("657468657265756d000000000000000000000000000000000000000000000000")) // output[0][0] value
+ buff.Write(common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000b")) // output[0][1] length
+ buff.Write(common.Hex2Bytes("676f2d657468657265756d000000000000000000000000000000000000000000")) // output[0][1] value
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002")) // output[1] length
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000064")) // output[1][0] value
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000065")) // output[1][1] value
+ ret1, ret1Exp := new([]string), []string{"ethereum", "go-ethereum"}
+ ret2, ret2Exp := new([]*big.Int), []*big.Int{big.NewInt(100), big.NewInt(101)}
+ if err := abi.UnpackIntoInterface(&[]interface{}{ret1, ret2}, "multi", buff.Bytes()); err != nil {
+ t.Fatal(err)
+ }
+ if !reflect.DeepEqual(*ret1, ret1Exp) {
+ t.Error("string slice result", *ret1, "!= Expected", ret1Exp)
+ }
+ if !reflect.DeepEqual(*ret2, ret2Exp) {
+ t.Error("uint256 slice result", *ret2, "!= Expected", ret2Exp)
+ }
+}
+
+func TestMultiReturnWithDeeplyNestedArray(t *testing.T) {
+ // Similar to TestMultiReturnWithArray, but with a special case in mind:
+ // values of nested static arrays count towards the size as well, and any element following
+ // after such nested array argument should be read with the correct offset,
+ // so that it does not read content from the previous array argument.
+ const definition = `[{"name" : "multi", "type": "function", "outputs": [{"type": "uint64[3][2][4]"}, {"type": "uint64"}]}]`
+ abi, err := JSON(strings.NewReader(definition))
+ if err != nil {
+ t.Fatal(err)
+ }
+ buff := new(bytes.Buffer)
+ // construct the test array, each 3 char element is joined with 61 '0' chars,
+ // to from the ((3 + 61) * 0.5) = 32 byte elements in the array.
+ buff.Write(common.Hex2Bytes(strings.Join([]string{
+ "", //empty, to apply the 61-char separator to the first element as well.
+ "111", "112", "113", "121", "122", "123",
+ "211", "212", "213", "221", "222", "223",
+ "311", "312", "313", "321", "322", "323",
+ "411", "412", "413", "421", "422", "423",
+ }, "0000000000000000000000000000000000000000000000000000000000000")))
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000009876"))
+
+ ret1, ret1Exp := new([4][2][3]uint64), [4][2][3]uint64{
+ {{0x111, 0x112, 0x113}, {0x121, 0x122, 0x123}},
+ {{0x211, 0x212, 0x213}, {0x221, 0x222, 0x223}},
+ {{0x311, 0x312, 0x313}, {0x321, 0x322, 0x323}},
+ {{0x411, 0x412, 0x413}, {0x421, 0x422, 0x423}},
+ }
+ ret2, ret2Exp := new(uint64), uint64(0x9876)
+ if err := abi.UnpackIntoInterface(&[]interface{}{ret1, ret2}, "multi", buff.Bytes()); err != nil {
+ t.Fatal(err)
+ }
+ if !reflect.DeepEqual(*ret1, ret1Exp) {
+ t.Error("array result", *ret1, "!= Expected", ret1Exp)
+ }
+ if *ret2 != ret2Exp {
+ t.Error("int result", *ret2, "!= Expected", ret2Exp)
+ }
+}
+
+func TestUnmarshal(t *testing.T) {
+ const definition = `[
+ { "name" : "int", "type": "function", "outputs": [ { "type": "uint256" } ] },
+ { "name" : "bool", "type": "function", "outputs": [ { "type": "bool" } ] },
+ { "name" : "bytes", "type": "function", "outputs": [ { "type": "bytes" } ] },
+ { "name" : "fixed", "type": "function", "outputs": [ { "type": "bytes32" } ] },
+ { "name" : "multi", "type": "function", "outputs": [ { "type": "bytes" }, { "type": "bytes" } ] },
+ { "name" : "intArraySingle", "type": "function", "outputs": [ { "type": "uint256[3]" } ] },
+ { "name" : "addressSliceSingle", "type": "function", "outputs": [ { "type": "address[]" } ] },
+ { "name" : "addressSliceDouble", "type": "function", "outputs": [ { "name": "a", "type": "address[]" }, { "name": "b", "type": "address[]" } ] },
+ { "name" : "mixedBytes", "type": "function", "stateMutability" : "view", "outputs": [ { "name": "a", "type": "bytes" }, { "name": "b", "type": "bytes32" } ] }]`
+
+ abi, err := JSON(strings.NewReader(definition))
+ if err != nil {
+ t.Fatal(err)
+ }
+ buff := new(bytes.Buffer)
+
+ // marshall mixed bytes (mixedBytes)
+ p0, p0Exp := []byte{}, common.Hex2Bytes("01020000000000000000")
+ p1, p1Exp := [32]byte{}, common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000ddeeff")
+ mixedBytes := []interface{}{&p0, &p1}
+
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000040"))
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000ddeeff"))
+ buff.Write(common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000a"))
+ buff.Write(common.Hex2Bytes("0102000000000000000000000000000000000000000000000000000000000000"))
+
+ err = abi.UnpackIntoInterface(&mixedBytes, "mixedBytes", buff.Bytes())
+ if err != nil {
+ t.Error(err)
+ } else {
+ if !bytes.Equal(p0, p0Exp) {
+ t.Errorf("unexpected value unpacked: want %x, got %x", p0Exp, p0)
+ }
+
+ if !bytes.Equal(p1[:], p1Exp) {
+ t.Errorf("unexpected value unpacked: want %x, got %x", p1Exp, p1)
+ }
+ }
+
+ // marshal int
+ var Int *big.Int
+ err = abi.UnpackIntoInterface(&Int, "int", common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001"))
+ if err != nil {
+ t.Error(err)
+ }
+
+ if Int == nil || Int.Cmp(big.NewInt(1)) != 0 {
+ t.Error("expected Int to be 1 got", Int)
+ }
+
+ // marshal bool
+ var Bool bool
+ err = abi.UnpackIntoInterface(&Bool, "bool", common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001"))
+ if err != nil {
+ t.Error(err)
+ }
+
+ if !Bool {
+ t.Error("expected Bool to be true")
+ }
+
+ // marshal dynamic bytes max length 32
+ buff.Reset()
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020"))
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020"))
+ bytesOut := common.RightPadBytes([]byte("hello"), 32)
+ buff.Write(bytesOut)
+
+ var Bytes []byte
+ err = abi.UnpackIntoInterface(&Bytes, "bytes", buff.Bytes())
+ if err != nil {
+ t.Error(err)
+ }
+
+ if !bytes.Equal(Bytes, bytesOut) {
+ t.Errorf("expected %x got %x", bytesOut, Bytes)
+ }
+
+ // marshall dynamic bytes max length 64
+ buff.Reset()
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020"))
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000040"))
+ bytesOut = common.RightPadBytes([]byte("hello"), 64)
+ buff.Write(bytesOut)
+
+ err = abi.UnpackIntoInterface(&Bytes, "bytes", buff.Bytes())
+ if err != nil {
+ t.Error(err)
+ }
+
+ if !bytes.Equal(Bytes, bytesOut) {
+ t.Errorf("expected %x got %x", bytesOut, Bytes)
+ }
+
+ // marshall dynamic bytes max length 64
+ buff.Reset()
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020"))
+ buff.Write(common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000003f"))
+ bytesOut = common.RightPadBytes([]byte("hello"), 64)
+ buff.Write(bytesOut)
+
+ err = abi.UnpackIntoInterface(&Bytes, "bytes", buff.Bytes())
+ if err != nil {
+ t.Error(err)
+ }
+
+ if !bytes.Equal(Bytes, bytesOut[:len(bytesOut)-1]) {
+ t.Errorf("expected %x got %x", bytesOut[:len(bytesOut)-1], Bytes)
+ }
+
+ // marshal dynamic bytes output empty
+ err = abi.UnpackIntoInterface(&Bytes, "bytes", nil)
+ if err == nil {
+ t.Error("expected error")
+ }
+
+ // marshal dynamic bytes length 5
+ buff.Reset()
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020"))
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000005"))
+ buff.Write(common.RightPadBytes([]byte("hello"), 32))
+
+ err = abi.UnpackIntoInterface(&Bytes, "bytes", buff.Bytes())
+ if err != nil {
+ t.Error(err)
+ }
+
+ if !bytes.Equal(Bytes, []byte("hello")) {
+ t.Errorf("expected %x got %x", bytesOut, Bytes)
+ }
+
+ // marshal dynamic bytes length 5
+ buff.Reset()
+ buff.Write(common.RightPadBytes([]byte("hello"), 32))
+
+ var hash common.Hash
+ err = abi.UnpackIntoInterface(&hash, "fixed", buff.Bytes())
+ if err != nil {
+ t.Error(err)
+ }
+
+ helloHash := common.BytesToHash(common.RightPadBytes([]byte("hello"), 32))
+ if hash != helloHash {
+ t.Errorf("Expected %x to equal %x", hash, helloHash)
+ }
+
+ // marshal error
+ buff.Reset()
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020"))
+ err = abi.UnpackIntoInterface(&Bytes, "bytes", buff.Bytes())
+ if err == nil {
+ t.Error("expected error")
+ }
+
+ err = abi.UnpackIntoInterface(&Bytes, "multi", make([]byte, 64))
+ if err == nil {
+ t.Error("expected error")
+ }
+
+ buff.Reset()
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001"))
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002"))
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000003"))
+ // marshal int array
+ var intArray [3]*big.Int
+ err = abi.UnpackIntoInterface(&intArray, "intArraySingle", buff.Bytes())
+ if err != nil {
+ t.Error(err)
+ }
+ var testAgainstIntArray [3]*big.Int
+ testAgainstIntArray[0] = big.NewInt(1)
+ testAgainstIntArray[1] = big.NewInt(2)
+ testAgainstIntArray[2] = big.NewInt(3)
+
+ for i, Int := range intArray {
+ if Int.Cmp(testAgainstIntArray[i]) != 0 {
+ t.Errorf("expected %v, got %v", testAgainstIntArray[i], Int)
+ }
+ }
+ // marshal address slice
+ buff.Reset()
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020")) // offset
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001")) // size
+ buff.Write(common.Hex2Bytes("0000000000000000000000000100000000000000000000000000000000000000"))
+
+ var outAddr []common.Address
+ err = abi.UnpackIntoInterface(&outAddr, "addressSliceSingle", buff.Bytes())
+ if err != nil {
+ t.Fatal("didn't expect error:", err)
+ }
+
+ if len(outAddr) != 1 {
+ t.Fatal("expected 1 item, got", len(outAddr))
+ }
+
+ if outAddr[0] != (common.Address{1}) {
+ t.Errorf("expected %x, got %x", common.Address{1}, outAddr[0])
+ }
+
+ // marshal multiple address slice
+ buff.Reset()
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000040")) // offset
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000080")) // offset
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001")) // size
+ buff.Write(common.Hex2Bytes("0000000000000000000000000100000000000000000000000000000000000000"))
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002")) // size
+ buff.Write(common.Hex2Bytes("0000000000000000000000000200000000000000000000000000000000000000"))
+ buff.Write(common.Hex2Bytes("0000000000000000000000000300000000000000000000000000000000000000"))
+
+ var outAddrStruct struct {
+ A []common.Address
+ B []common.Address
+ }
+ err = abi.UnpackIntoInterface(&outAddrStruct, "addressSliceDouble", buff.Bytes())
+ if err != nil {
+ t.Fatal("didn't expect error:", err)
+ }
+
+ if len(outAddrStruct.A) != 1 {
+ t.Fatal("expected 1 item, got", len(outAddrStruct.A))
+ }
+
+ if outAddrStruct.A[0] != (common.Address{1}) {
+ t.Errorf("expected %x, got %x", common.Address{1}, outAddrStruct.A[0])
+ }
+
+ if len(outAddrStruct.B) != 2 {
+ t.Fatal("expected 1 item, got", len(outAddrStruct.B))
+ }
+
+ if outAddrStruct.B[0] != (common.Address{2}) {
+ t.Errorf("expected %x, got %x", common.Address{2}, outAddrStruct.B[0])
+ }
+ if outAddrStruct.B[1] != (common.Address{3}) {
+ t.Errorf("expected %x, got %x", common.Address{3}, outAddrStruct.B[1])
+ }
+
+ // marshal invalid address slice
+ buff.Reset()
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000100"))
+
+ err = abi.UnpackIntoInterface(&outAddr, "addressSliceSingle", buff.Bytes())
+ if err == nil {
+ t.Fatal("expected error:", err)
+ }
+}
+
+func TestUnpackTuple(t *testing.T) {
+ const simpleTuple = `[{"name":"tuple","type":"function","outputs":[{"type":"tuple","name":"ret","components":[{"type":"int256","name":"a"},{"type":"int256","name":"b"}]}]}]`
+ abi, err := JSON(strings.NewReader(simpleTuple))
+ if err != nil {
+ t.Fatal(err)
+ }
+ buff := new(bytes.Buffer)
+
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001")) // ret[a] = 1
+ buff.Write(common.Hex2Bytes("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) // ret[b] = -1
+
+ // If the result is single tuple, use struct as return value container directly.
+ type v struct {
+ A *big.Int
+ B *big.Int
+ }
+ type r struct {
+ Result v
+ }
+ var ret0 = new(r)
+ err = abi.UnpackIntoInterface(ret0, "tuple", buff.Bytes())
+
+ if err != nil {
+ t.Error(err)
+ } else {
+ if ret0.Result.A.Cmp(big.NewInt(1)) != 0 {
+ t.Errorf("unexpected value unpacked: want %x, got %x", 1, ret0.Result.A)
+ }
+ if ret0.Result.B.Cmp(big.NewInt(-1)) != 0 {
+ t.Errorf("unexpected value unpacked: want %x, got %x", -1, ret0.Result.B)
+ }
+ }
+
+ // Test nested tuple
+ const nestedTuple = `[{"name":"tuple","type":"function","outputs":[
+ {"type":"tuple","name":"s","components":[{"type":"uint256","name":"a"},{"type":"uint256[]","name":"b"},{"type":"tuple[]","name":"c","components":[{"name":"x", "type":"uint256"},{"name":"y","type":"uint256"}]}]},
+ {"type":"tuple","name":"t","components":[{"name":"x", "type":"uint256"},{"name":"y","type":"uint256"}]},
+ {"type":"uint256","name":"a"}
+ ]}]`
+
+ abi, err = JSON(strings.NewReader(nestedTuple))
+ if err != nil {
+ t.Fatal(err)
+ }
+ buff.Reset()
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000080")) // s offset
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000")) // t.X = 0
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001")) // t.Y = 1
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001")) // a = 1
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001")) // s.A = 1
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000060")) // s.B offset
+ buff.Write(common.Hex2Bytes("00000000000000000000000000000000000000000000000000000000000000c0")) // s.C offset
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002")) // s.B length
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001")) // s.B[0] = 1
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002")) // s.B[0] = 2
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002")) // s.C length
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001")) // s.C[0].X
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002")) // s.C[0].Y
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002")) // s.C[1].X
+ buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001")) // s.C[1].Y
+
+ type T struct {
+ X *big.Int `abi:"x"`
+ Z *big.Int `abi:"y"` // Test whether the abi tag works.
+ }
+
+ type S struct {
+ A *big.Int
+ B []*big.Int
+ C []T
+ }
+
+ type Ret struct {
+ FieldS S `abi:"s"`
+ FieldT T `abi:"t"`
+ A *big.Int
+ }
+ var ret Ret
+ var expected = Ret{
+ FieldS: S{
+ A: big.NewInt(1),
+ B: []*big.Int{big.NewInt(1), big.NewInt(2)},
+ C: []T{
+ {big.NewInt(1), big.NewInt(2)},
+ {big.NewInt(2), big.NewInt(1)},
+ },
+ },
+ FieldT: T{
+ big.NewInt(0), big.NewInt(1),
+ },
+ A: big.NewInt(1),
+ }
+
+ err = abi.UnpackIntoInterface(&ret, "tuple", buff.Bytes())
+ if err != nil {
+ t.Error(err)
+ }
+ if reflect.DeepEqual(ret, expected) {
+ t.Error("unexpected unpack value")
+ }
+}
+
+func TestOOMMaliciousInput(t *testing.T) {
+ oomTests := []unpackTest{
+ {
+ def: `[{"type": "uint8[]"}]`,
+ enc: "0000000000000000000000000000000000000000000000000000000000000020" + // offset
+ "0000000000000000000000000000000000000000000000000000000000000003" + // num elems
+ "0000000000000000000000000000000000000000000000000000000000000001" + // elem 1
+ "0000000000000000000000000000000000000000000000000000000000000002", // elem 2
+ },
+ { // Length larger than 64 bits
+ def: `[{"type": "uint8[]"}]`,
+ enc: "0000000000000000000000000000000000000000000000000000000000000020" + // offset
+ "00ffffffffffffffffffffffffffffffffffffffffffffff0000000000000002" + // num elems
+ "0000000000000000000000000000000000000000000000000000000000000001" + // elem 1
+ "0000000000000000000000000000000000000000000000000000000000000002", // elem 2
+ },
+ { // Offset very large (over 64 bits)
+ def: `[{"type": "uint8[]"}]`,
+ enc: "00ffffffffffffffffffffffffffffffffffffffffffffff0000000000000020" + // offset
+ "0000000000000000000000000000000000000000000000000000000000000002" + // num elems
+ "0000000000000000000000000000000000000000000000000000000000000001" + // elem 1
+ "0000000000000000000000000000000000000000000000000000000000000002", // elem 2
+ },
+ { // Offset very large (below 64 bits)
+ def: `[{"type": "uint8[]"}]`,
+ enc: "0000000000000000000000000000000000000000000000007ffffffffff00020" + // offset
+ "0000000000000000000000000000000000000000000000000000000000000002" + // num elems
+ "0000000000000000000000000000000000000000000000000000000000000001" + // elem 1
+ "0000000000000000000000000000000000000000000000000000000000000002", // elem 2
+ },
+ { // Offset negative (as 64 bit)
+ def: `[{"type": "uint8[]"}]`,
+ enc: "000000000000000000000000000000000000000000000000f000000000000020" + // offset
+ "0000000000000000000000000000000000000000000000000000000000000002" + // num elems
+ "0000000000000000000000000000000000000000000000000000000000000001" + // elem 1
+ "0000000000000000000000000000000000000000000000000000000000000002", // elem 2
+ },
+
+ { // Negative length
+ def: `[{"type": "uint8[]"}]`,
+ enc: "0000000000000000000000000000000000000000000000000000000000000020" + // offset
+ "000000000000000000000000000000000000000000000000f000000000000002" + // num elems
+ "0000000000000000000000000000000000000000000000000000000000000001" + // elem 1
+ "0000000000000000000000000000000000000000000000000000000000000002", // elem 2
+ },
+ { // Very large length
+ def: `[{"type": "uint8[]"}]`,
+ enc: "0000000000000000000000000000000000000000000000000000000000000020" + // offset
+ "0000000000000000000000000000000000000000000000007fffffffff000002" + // num elems
+ "0000000000000000000000000000000000000000000000000000000000000001" + // elem 1
+ "0000000000000000000000000000000000000000000000000000000000000002", // elem 2
+ },
+ }
+ for i, test := range oomTests {
+ def := fmt.Sprintf(`[{ "name" : "method", "type": "function", "outputs": %s}]`, test.def)
+ abi, err := JSON(strings.NewReader(def))
+ if err != nil {
+ t.Fatalf("invalid ABI definition %s: %v", def, err)
+ }
+ encb, err := hex.DecodeString(test.enc)
+ if err != nil {
+ t.Fatalf("invalid hex: %s" + test.enc)
+ }
+ _, err = abi.Methods["method"].Outputs.UnpackValues(encb)
+ if err == nil {
+ t.Fatalf("Expected error on malicious input, test %d", i)
+ }
+ }
+}
diff --git a/abigen/accounts/abi/utils.go b/abigen/accounts/abi/utils.go
new file mode 100644
index 00000000..e24df5b7
--- /dev/null
+++ b/abigen/accounts/abi/utils.go
@@ -0,0 +1,41 @@
+// Copyright 2022 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package abi
+
+import "fmt"
+
+// ResolveNameConflict returns the next available name for a given thing.
+// This helper can be used for lots of purposes:
+//
+// - In solidity function overloading is supported, this function can fix
+// the name conflicts of overloaded functions.
+// - In golang binding generation, the parameter(in function, event, error,
+// and struct definition) name will be converted to camelcase style which
+// may eventually lead to name conflicts.
+//
+// Name conflicts are mostly resolved by adding number suffix.
+// e.g. if the abi contains Methods send, send1
+// ResolveNameConflict would return send2 for input send.
+func ResolveNameConflict(rawName string, used func(string) bool) string {
+ name := rawName
+ ok := used(name)
+ for idx := 0; ok; idx++ {
+ name = fmt.Sprintf("%s%d", rawName, idx)
+ ok = used(name)
+ }
+ return name
+}
diff --git a/abigen/cmd/abigen/flags.go b/abigen/cmd/abigen/flags.go
new file mode 100644
index 00000000..bfea4bdc
--- /dev/null
+++ b/abigen/cmd/abigen/flags.go
@@ -0,0 +1,153 @@
+// Copyright 2020 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package main
+
+import (
+ "os"
+ "path/filepath"
+
+ "github.com/ethereum/go-ethereum/params"
+ "gopkg.in/urfave/cli.v1"
+)
+
+var (
+ CommandHelpTemplate = `{{.cmd.Name}}{{if .cmd.Subcommands}} command{{end}}{{if .cmd.Flags}} [command options]{{end}} {{.cmd.ArgsUsage}}
+{{if .cmd.Description}}{{.cmd.Description}}
+{{end}}{{if .cmd.Subcommands}}
+SUBCOMMANDS:
+ {{range .cmd.Subcommands}}{{.Name}}{{with .ShortName}}, {{.}}{{end}}{{ "\t" }}{{.Usage}}
+ {{end}}{{end}}{{if .categorizedFlags}}
+{{range $idx, $categorized := .categorizedFlags}}{{$categorized.Name}} OPTIONS:
+{{range $categorized.Flags}}{{"\t"}}{{.}}
+{{end}}
+{{end}}{{end}}`
+
+ OriginCommandHelpTemplate = `{{.Name}}{{if .Subcommands}} command{{end}}{{if .Flags}} [command options]{{end}} {{.ArgsUsage}}
+{{if .Description}}{{.Description}}
+{{end}}{{if .Subcommands}}
+SUBCOMMANDS:
+ {{range .Subcommands}}{{.Name}}{{with .ShortName}}, {{.}}{{end}}{{ "\t" }}{{.Usage}}
+ {{end}}{{end}}{{if .Flags}}
+OPTIONS:
+{{range $.Flags}} {{.}}
+{{end}}
+{{end}}`
+
+ // AppHelpTemplate is the test template for the default, global app help topic.
+ AppHelpTemplate = `NAME:
+ {{.App.Name}} - {{.App.Usage}}
+
+ Copyright 2013-2022 The go-ethereum Authors
+
+USAGE:
+ {{.App.HelpName}} [options]{{if .App.Commands}} [command] [command options]{{end}} {{if .App.ArgsUsage}}{{.App.ArgsUsage}}{{else}}[arguments...]{{end}}
+ {{if .App.Version}}
+VERSION:
+ {{.App.Version}}
+ {{end}}{{if len .App.Authors}}
+AUTHOR(S):
+ {{range .App.Authors}}{{ . }}{{end}}
+ {{end}}{{if .App.Commands}}
+COMMANDS:
+ {{range .App.Commands}}{{join .Names ", "}}{{ "\t" }}{{.Usage}}
+ {{end}}{{end}}{{if .FlagGroups}}
+{{range .FlagGroups}}{{.Name}} OPTIONS:
+ {{range .Flags}}{{.}}
+ {{end}}
+{{end}}{{end}}{{if .App.Copyright }}
+COPYRIGHT:
+ {{.App.Copyright}}
+ {{end}}
+`
+ // ClefAppHelpTemplate is the template for the default, global app help topic.
+ ClefAppHelpTemplate = `NAME:
+ {{.App.Name}} - {{.App.Usage}}
+
+ Copyright 2013-2022 The go-ethereum Authors
+
+USAGE:
+ {{.App.HelpName}} [options]{{if .App.Commands}} command [command options]{{end}} {{if .App.ArgsUsage}}{{.App.ArgsUsage}}{{else}}[arguments...]{{end}}
+ {{if .App.Version}}
+COMMANDS:
+ {{range .App.Commands}}{{join .Names ", "}}{{ "\t" }}{{.Usage}}
+ {{end}}{{end}}{{if .FlagGroups}}
+{{range .FlagGroups}}{{.Name}} OPTIONS:
+ {{range .Flags}}{{.}}
+ {{end}}
+{{end}}{{end}}{{if .App.Copyright }}
+COPYRIGHT:
+ {{.App.Copyright}}
+ {{end}}
+`
+)
+
+// HelpData is a one shot struct to pass to the usage template
+type HelpData struct {
+ App interface{}
+ FlagGroups []FlagGroup
+}
+
+// FlagGroup is a collection of flags belonging to a single topic.
+type FlagGroup struct {
+ Name string
+ Flags []cli.Flag
+}
+
+// ByCategory sorts an array of FlagGroup by Name in the order
+// defined in AppHelpFlagGroups.
+type ByCategory []FlagGroup
+
+func (a ByCategory) Len() int { return len(a) }
+func (a ByCategory) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+func (a ByCategory) Less(i, j int) bool {
+ iCat, jCat := a[i].Name, a[j].Name
+ iIdx, jIdx := len(a), len(a) // ensure non categorized flags come last
+
+ for i, group := range a {
+ if iCat == group.Name {
+ iIdx = i
+ }
+ if jCat == group.Name {
+ jIdx = i
+ }
+ }
+
+ return iIdx < jIdx
+}
+
+func FlagCategory(flag cli.Flag, flagGroups []FlagGroup) string {
+ for _, category := range flagGroups {
+ for _, flg := range category.Flags {
+ if flg.GetName() == flag.GetName() {
+ return category.Name
+ }
+ }
+ }
+ return "MISC"
+}
+
+// NewApp creates an app with sane defaults.
+func NewApp(gitCommit, gitDate, usage string) *cli.App {
+ app := cli.NewApp()
+ app.EnableBashCompletion = true
+ app.Name = filepath.Base(os.Args[0])
+ app.Author = ""
+ app.Email = ""
+ app.Version = params.VersionWithCommit(gitCommit, gitDate)
+ app.Usage = usage
+ return app
+}
diff --git a/abigen/cmd/abigen/main.go b/abigen/cmd/abigen/main.go
new file mode 100644
index 00000000..ab0b7f6a
--- /dev/null
+++ b/abigen/cmd/abigen/main.go
@@ -0,0 +1,297 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see .
+
+package main
+
+import (
+ "encoding/json"
+ "fmt"
+ "io"
+ "os"
+ "regexp"
+ "strings"
+
+ "github.com/ethereum/go-ethereum/cmd/utils"
+ "github.com/ethereum/go-ethereum/common/compiler"
+ "github.com/ethereum/go-ethereum/crypto"
+ "github.com/ethereum/go-ethereum/log"
+ "gitlab.com/alphaticks/abigen-starknet/accounts/abi/bind"
+ "gopkg.in/urfave/cli.v1"
+)
+
+var (
+ // Git SHA1 commit hash of the release (set via linker flags)
+ gitCommit = ""
+ gitDate = ""
+
+ app *cli.App
+
+ // Flags needed by abigen
+ abiFlag = cli.StringFlag{
+ Name: "abi",
+ Usage: "Path to the Ethereum contract ABI json to bind, - for STDIN",
+ }
+ starkAbiFlag = cli.StringFlag{
+ Name: "stark-abi",
+ Usage: "Path to the Starknet contract ABI json to bind, - for STDIN",
+ }
+ binFlag = cli.StringFlag{
+ Name: "bin",
+ Usage: "Path to the Ethereum contract bytecode (generate deploy method)",
+ }
+ typeFlag = cli.StringFlag{
+ Name: "type",
+ Usage: "Struct name for the binding (default = package name)",
+ }
+ jsonFlag = cli.StringFlag{
+ Name: "combined-json",
+ Usage: "Path to the combined-json file generated by compiler, - for STDIN",
+ }
+ excFlag = cli.StringFlag{
+ Name: "exc",
+ Usage: "Comma separated types to exclude from binding",
+ }
+ pkgFlag = cli.StringFlag{
+ Name: "pkg",
+ Usage: "Package name to generate the binding into",
+ }
+ outFlag = cli.StringFlag{
+ Name: "out",
+ Usage: "Output file for the generated binding (default = stdout)",
+ }
+ langFlag = cli.StringFlag{
+ Name: "lang",
+ Usage: "Destination language for the bindings (go, java, objc)",
+ Value: "go",
+ }
+ aliasFlag = cli.StringFlag{
+ Name: "alias",
+ Usage: "Comma separated aliases for function and event renaming, e.g. original1=alias1, original2=alias2",
+ }
+)
+
+func init() {
+ app = NewApp(gitCommit, gitDate, "ethereum checkpoint helper tool")
+ app.Flags = []cli.Flag{
+ abiFlag,
+ starkAbiFlag,
+ binFlag,
+ typeFlag,
+ jsonFlag,
+ excFlag,
+ pkgFlag,
+ outFlag,
+ langFlag,
+ aliasFlag,
+ }
+ app.Action = utils.MigrateFlags(Abigen)
+ cli.CommandHelpTemplate = OriginCommandHelpTemplate
+}
+
+func Abigen(c *cli.Context) error {
+ utils.CheckExclusive(c, abiFlag, jsonFlag) // Only one source can be selected.
+ if c.GlobalString(pkgFlag.Name) == "" {
+ utils.Fatalf("No destination package specified (--pkg)")
+ }
+ var lang bind.Lang
+ switch c.GlobalString(langFlag.Name) {
+ case "go":
+ lang = bind.LangGo
+ case "java":
+ lang = bind.LangJava
+ case "objc":
+ lang = bind.LangObjC
+ utils.Fatalf("Objc binding generation is uncompleted")
+ default:
+ utils.Fatalf("Unsupported destination language \"%s\" (--lang)", c.GlobalString(langFlag.Name))
+ }
+ // If the entire solidity code was specified, build and bind based on that
+ var (
+ abis []string
+ bins []string
+ types []string
+ sigs []map[string]string
+ libs = make(map[string]string)
+ aliases = make(map[string]string)
+ )
+ if c.GlobalString(starkAbiFlag.Name) != "" && c.GlobalString(abiFlag.Name) != "" {
+ utils.Fatalf("Cannot have Starknet abi and Ethereum abi flags set")
+ }
+ if c.GlobalString(starkAbiFlag.Name) != "" {
+ // Load up the ABI, optional bytecode and type name from the parameters
+ var (
+ abi []byte
+ err error
+ )
+ input := c.GlobalString(starkAbiFlag.Name)
+ if input == "-" {
+ abi, err = io.ReadAll(os.Stdin)
+ } else {
+ abi, err = os.ReadFile(input)
+ }
+ if err != nil {
+ utils.Fatalf("Failed to read input ABI: %v", err)
+ }
+ abis = append(abis, string(abi))
+
+ var bin []byte
+ if binFile := c.GlobalString(binFlag.Name); binFile != "" {
+ if bin, err = os.ReadFile(binFile); err != nil {
+ utils.Fatalf("Failed to read input bytecode: %v", err)
+ }
+ if strings.Contains(string(bin), "//") {
+ utils.Fatalf("Contract has additional library references, please use other mode(e.g. --combined-json) to catch library infos")
+ }
+ }
+ bins = append(bins, string(bin))
+
+ kind := c.GlobalString(typeFlag.Name)
+ if kind == "" {
+ kind = c.GlobalString(pkgFlag.Name)
+ }
+ types = append(types, kind)
+ for i, ab := range abis {
+ tmp := strings.ReplaceAll(ab, "felt", "uint256")
+ tmp = strings.ReplaceAll(tmp, "members", "inputs")
+ tmp = strings.ReplaceAll(tmp, "Uint256", "uint256")
+ tmp = strings.ReplaceAll(tmp, "data", "inputs")
+ tmp = "[" + fmt.Sprintf("\n\t{\n \t\t\"chain\":\"Starknet\", \n \t\t\"type\": \"-\" \n \t},") + tmp[1:]
+ abis[i] = tmp
+ }
+ }
+ if c.GlobalString(abiFlag.Name) != "" {
+ // Load up the ABI, optional bytecode and type name from the parameters
+ var (
+ abi []byte
+ err error
+ )
+ input := c.GlobalString(abiFlag.Name)
+ if input == "-" {
+ abi, err = io.ReadAll(os.Stdin)
+ } else {
+ abi, err = os.ReadFile(input)
+ }
+ if err != nil {
+ utils.Fatalf("Failed to read input ABI: %v", err)
+ }
+ abis = append(abis, string(abi))
+
+ var bin []byte
+ if binFile := c.GlobalString(binFlag.Name); binFile != "" {
+ if bin, err = os.ReadFile(binFile); err != nil {
+ utils.Fatalf("Failed to read input bytecode: %v", err)
+ }
+ if strings.Contains(string(bin), "//") {
+ utils.Fatalf("Contract has additional library references, please use other mode(e.g. --combined-json) to catch library infos")
+ }
+ }
+ bins = append(bins, string(bin))
+
+ kind := c.GlobalString(typeFlag.Name)
+ if kind == "" {
+ kind = c.GlobalString(pkgFlag.Name)
+ }
+ types = append(types, kind)
+ for i, ab := range abis {
+ tmp := "[" + fmt.Sprintf("\n\t{\n \t\t\"chain\":\"Ethereum\", \n \t\t\"type\": \"-\" \n \t},") + ab[1:]
+ abis[i] = tmp
+ }
+ } else {
+ // Generate the list of types to exclude from binding
+ exclude := make(map[string]bool)
+ for _, kind := range strings.Split(c.GlobalString(excFlag.Name), ",") {
+ exclude[strings.ToLower(kind)] = true
+ }
+ var contracts map[string]*compiler.Contract
+
+ if c.GlobalIsSet(jsonFlag.Name) {
+ var (
+ input = c.GlobalString(jsonFlag.Name)
+ jsonOutput []byte
+ err error
+ )
+ if input == "-" {
+ jsonOutput, err = io.ReadAll(os.Stdin)
+ } else {
+ jsonOutput, err = os.ReadFile(input)
+ }
+ if err != nil {
+ utils.Fatalf("Failed to read combined-json: %v", err)
+ }
+ contracts, err = compiler.ParseCombinedJSON(jsonOutput, "", "", "", "")
+ if err != nil {
+ utils.Fatalf("Failed to read contract information from json output: %v", err)
+ }
+ }
+ // Gather all non-excluded contract for binding
+ for name, contract := range contracts {
+ if exclude[strings.ToLower(name)] {
+ continue
+ }
+ abi, err := json.Marshal(contract.Info.AbiDefinition) // Flatten the compiler parse
+ if err != nil {
+ utils.Fatalf("Failed to parse ABIs from compiler output: %v", err)
+ }
+ abis = append(abis, string(abi))
+ bins = append(bins, contract.Code)
+ sigs = append(sigs, contract.Hashes)
+ nameParts := strings.Split(name, ":")
+ types = append(types, nameParts[len(nameParts)-1])
+
+ // Derive the library placeholder which is a 34 character prefix of the
+ // hex encoding of the keccak256 hash of the fully qualified library name.
+ // Note that the fully qualified library name is the path of its source
+ // file and the library name separated by ":".
+ libPattern := crypto.Keccak256Hash([]byte(name)).String()[2:36] // the first 2 chars are 0x
+ libs[libPattern] = nameParts[len(nameParts)-1]
+ }
+ }
+ // Extract all aliases from the flags
+ if c.GlobalIsSet(aliasFlag.Name) {
+ // We support multi-versions for aliasing
+ // e.g.
+ // foo=bar,foo2=bar2
+ // foo:bar,foo2:bar2
+ re := regexp.MustCompile(`(?:(\w+)[:=](\w+))`)
+ submatches := re.FindAllStringSubmatch(c.GlobalString(aliasFlag.Name), -1)
+ for _, match := range submatches {
+ aliases[match[1]] = match[2]
+ }
+ }
+ // Generate the contract binding
+ code, err := bind.Bind(types, abis, bins, sigs, c.GlobalString(pkgFlag.Name), lang, libs, aliases)
+ if err != nil {
+ utils.Fatalf("Failed to generate ABI binding: %v", err)
+ }
+ // Either flush it out to a file or display on the standard output
+ if !c.GlobalIsSet(outFlag.Name) {
+ fmt.Printf("%s\n", code)
+ return nil
+ }
+ if err := os.WriteFile(c.GlobalString(outFlag.Name), []byte(code), 0600); err != nil {
+ utils.Fatalf("Failed to write ABI binding: %v", err)
+ }
+ return nil
+}
+
+func main() {
+ log.Root().SetHandler(log.LvlFilterHandler(log.LvlInfo, log.StreamHandler(os.Stderr, log.TerminalFormat(true))))
+
+ if err := app.Run(os.Args); err != nil {
+ fmt.Fprintln(os.Stderr, err)
+ os.Exit(1)
+ }
+}
diff --git a/abigen/go.mod b/abigen/go.mod
new file mode 100644
index 00000000..e5511627
--- /dev/null
+++ b/abigen/go.mod
@@ -0,0 +1,67 @@
+module gitlab.com/alphaticks/abigen-starknet
+
+go 1.18
+
+require (
+ github.com/davecgh/go-spew v1.1.1
+ github.com/ethereum/go-ethereum v1.10.19
+ github.com/stretchr/testify v1.7.5
+ gopkg.in/urfave/cli.v1 v1.20.0
+)
+
+require (
+ github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6 // indirect
+ github.com/VictoriaMetrics/fastcache v1.6.0 // indirect
+ github.com/btcsuite/btcd/btcec/v2 v2.2.0 // indirect
+ github.com/cespare/xxhash/v2 v2.1.1 // indirect
+ github.com/deckarep/golang-set v1.8.0 // indirect
+ github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 // indirect
+ github.com/deepmap/oapi-codegen v1.8.2 // indirect
+ github.com/edsrzf/mmap-go v1.0.0 // indirect
+ github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5 // indirect
+ github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff // indirect
+ github.com/go-ole/go-ole v1.2.1 // indirect
+ github.com/go-stack/stack v1.8.0 // indirect
+ github.com/golang-jwt/jwt/v4 v4.3.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/graph-gophers/graphql-go v1.3.0 // indirect
+ github.com/hashicorp/go-bexpr v0.1.10 // indirect
+ github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d // indirect
+ github.com/holiman/bloomfilter/v2 v2.0.3 // indirect
+ github.com/holiman/uint256 v1.2.0 // indirect
+ github.com/huin/goupnp v1.0.3 // indirect
+ github.com/influxdata/influxdb v1.8.3 // indirect
+ github.com/influxdata/influxdb-client-go/v2 v2.4.0 // indirect
+ github.com/influxdata/line-protocol v0.0.0-20210311194329-9aa0e372d097 // indirect
+ github.com/jackpal/go-nat-pmp v1.0.2 // indirect
+ github.com/mattn/go-colorable v0.1.8 // indirect
+ github.com/mattn/go-isatty v0.0.12 // indirect
+ github.com/mattn/go-runewidth v0.0.9 // indirect
+ github.com/mitchellh/mapstructure v1.4.1 // indirect
+ github.com/mitchellh/pointerstructure v1.2.0 // indirect
+ github.com/olekukonko/tablewriter v0.0.5 // indirect
+ github.com/opentracing/opentracing-go v1.1.0 // indirect
+ github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7 // indirect
+ github.com/pkg/errors v0.9.1 // indirect
+ github.com/pmezard/go-difflib v1.0.0 // indirect
+ github.com/prometheus/tsdb v0.7.1 // indirect
+ github.com/rjeczalik/notify v0.9.1 // indirect
+ github.com/rs/cors v1.7.0 // indirect
+ github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible // indirect
+ github.com/status-im/keycard-go v0.0.0-20190316090335-8537d3370df4 // 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
+ github.com/tyler-smith/go-bip39 v1.0.1-0.20181017060643-dbb3b84ba2ef // indirect
+ golang.org/x/crypto v0.0.0-20210921155107-089bfa567519 // indirect
+ golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f // indirect
+ golang.org/x/sync v0.0.0-20210220032951-036812b2e83c // indirect
+ golang.org/x/sys v0.0.0-20211019181941-9d821ace8654 // indirect
+ golang.org/x/text v0.3.7 // indirect
+ golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba // indirect
+ gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect
+ gopkg.in/yaml.v2 v2.4.0 // indirect
+ gopkg.in/yaml.v3 v3.0.1 // indirect
+)
diff --git a/abigen/go.sum b/abigen/go.sum
new file mode 100644
index 00000000..e7ead129
--- /dev/null
+++ b/abigen/go.sum
@@ -0,0 +1,552 @@
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
+cloud.google.com/go v0.43.0/go.mod h1:BOSR3VbTLkk6FDC/TcffxP4NF/FFBGA5ku+jvKOP7pg=
+cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
+cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
+cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=
+cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=
+cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To=
+cloud.google.com/go v0.51.0/go.mod h1:hWtGJ6gnXH+KgDv+V0zFGDvpi07n3z8ZNj3T1RW0Gcw=
+cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
+cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=
+cloud.google.com/go/bigtable v1.2.0/go.mod h1:JcVAOl45lrTmQfLj7T6TxyMzIN/3FGGcFm+2xVAli2o=
+cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
+cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
+cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw=
+cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
+cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos=
+collectd.org v0.3.0/go.mod h1:A/8DzQBkF6abtvrT2j/AU/4tiBgJWYyh0y/oB/4MlWE=
+dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
+github.com/DATA-DOG/go-sqlmock v1.3.3/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
+github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
+github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6 h1:fLjPD/aNc3UIOA6tDi6QXUemppXK3P9BI7mr2hd6gx8=
+github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6/go.mod h1:3eOhrUMpNV+6aFIbp5/iudMxNCF27Vw2OZgy4xEx0Fg=
+github.com/VictoriaMetrics/fastcache v1.6.0 h1:C/3Oi3EiBCqufydp1neRZkqcwmEiuRT9c3fqvvgKm5o=
+github.com/VictoriaMetrics/fastcache v1.6.0/go.mod h1:0qHz5QP0GMX4pfmMA/zt5RgfNuXJrTP0zS7DqpHGGTw=
+github.com/ajstarks/svgo v0.0.0-20180226025133-644b8db467af/go.mod h1:K08gAheRH3/J6wwsYMMT4xOr94bZjxIelGM0+d/wbFw=
+github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156 h1:eMwmnE/GDgah4HI848JfFxHt+iPb26b4zyfspmqY0/8=
+github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156/go.mod h1:Cb/ax3seSYIx7SuZdm2G2xzfwmv3TPSk2ucNfQESPXM=
+github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883/go.mod h1:rCTlJbsFo29Kk6CurOXKm700vrz8f0KW0JNfpkRJY/8=
+github.com/apache/arrow/go/arrow v0.0.0-20191024131854-af6fa24be0db/go.mod h1:VTxUBvSJ3s3eHAg65PNgrsn5BtqCRPdmyXh6rAfdxN0=
+github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
+github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
+github.com/bmizerany/pat v0.0.0-20170815010413-6226ea591a40/go.mod h1:8rLXio+WjiTceGBHIoTvn60HIbs7Hm7bcHjyrSqYB9c=
+github.com/boltdb/bolt v1.3.1/go.mod h1:clJnj/oiGkjum5o1McbSZDSLxVThjynRyGBgiAx27Ps=
+github.com/btcsuite/btcd/btcec/v2 v2.2.0 h1:fzn1qaOt32TuLjFlkzYSsBC35Q3KUjT1SwPxiMSCF5k=
+github.com/btcsuite/btcd/btcec/v2 v2.2.0/go.mod h1:U7MHm051Al6XmscBQ0BoNydpOTsFAn707034b5nY8zU=
+github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 h1:q0rUy8C/TYNBQS1+CGKw68tLOFYSNEs0TFnxxnS9+4U=
+github.com/c-bata/go-prompt v0.2.2/go.mod h1:VzqtzE2ksDBcdln8G7mk2RX9QyGjH+OVqOCSiVIqS34=
+github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
+github.com/cespare/cp v0.1.0 h1:SE+dxFebS7Iik5LK0tsi1k9ZCxEaFX4AjQmoyA+1dJk=
+github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
+github.com/cespare/xxhash/v2 v2.1.1 h1:6MnRN8NT7+YBpUIWxHtefFZOKTAPgGjpQSxqLNn0+qY=
+github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
+github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
+github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/cyberdelia/templates v0.0.0-20141128023046-ca7fffd4298c/go.mod h1:GyV+0YP4qX0UQ7r2MoYZ+AvYDp12OF5yg4q8rGnyNh4=
+github.com/dave/jennifer v1.2.0/go.mod h1:fIb+770HOpJ2fmN9EPPKOqm1vMGhB+TwXKMZhrIygKg=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/deckarep/golang-set v1.8.0 h1:sk9/l/KqpunDwP7pSjUg0keiOOLEnOBHzykLrsPppp4=
+github.com/deckarep/golang-set v1.8.0/go.mod h1:5nI87KwE7wgsBU1F4GKAw2Qod7p5kyS383rP6+o6qqo=
+github.com/decred/dcrd/crypto/blake256 v1.0.0 h1:/8DMNYp9SGi5f0w7uCm6d6M4OU2rGFK09Y2A4Xv7EE0=
+github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 h1:YLtO71vCjJRCBcrPMtQ9nqBsqpA1m5sE92cU+pd5Mcc=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1/go.mod h1:hyedUtir6IdtD/7lIxGeCxkaw7y45JueMRL4DIyJDKs=
+github.com/deepmap/oapi-codegen v1.6.0/go.mod h1:ryDa9AgbELGeB+YEXE1dR53yAjHwFvE9iAUlWl9Al3M=
+github.com/deepmap/oapi-codegen v1.8.2 h1:SegyeYGcdi0jLLrpbCMoJxnUUn8GBXHsvr4rbzjuhfU=
+github.com/deepmap/oapi-codegen v1.8.2/go.mod h1:YLgSKSDv/bZQB7N4ws6luhozi3cEdRktEqrX88CvjIw=
+github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
+github.com/dgryski/go-bitstream v0.0.0-20180413035011-3522498ce2c8/go.mod h1:VMaSuZ+SZcx/wljOQKvp5srsbCiKDEb6K2wC4+PiBmQ=
+github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
+github.com/docker/docker v1.6.2 h1:HlFGsy+9/xrgMmhmN+NGhCc5SHGJ7I+kHosRR1xc/aI=
+github.com/eclipse/paho.mqtt.golang v1.2.0/go.mod h1:H9keYFcgq3Qr5OUJm/JZI/i6U7joQ8SYLhZwfeOo6Ts=
+github.com/edsrzf/mmap-go v1.0.0 h1:CEBF7HpRnUCSJgGUb5h1Gm7e3VkmVDrR8lvWVLtrOFw=
+github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
+github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
+github.com/ethereum/go-ethereum v1.10.19 h1:EOR5JbL4MD5yeOqv8W2iC1s4NximrTjqFccUz8lyBRA=
+github.com/ethereum/go-ethereum v1.10.19/go.mod h1:IJBNMtzKcNHPtllYihy6BL2IgK1u+32JriaTbdt4v+w=
+github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5 h1:FtmdgXiUlNeRsoNMFlKLDt+S+6hbjVMEW6RGQ7aUf7c=
+github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0=
+github.com/fogleman/gg v1.2.1-0.20190220221249-0403632d5b90/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
+github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
+github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI=
+github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww=
+github.com/getkin/kin-openapi v0.53.0/go.mod h1:7Yn5whZr5kJi6t+kShccXS8ae1APpYTW6yheSwk8Yi4=
+github.com/getkin/kin-openapi v0.61.0/go.mod h1:7Yn5whZr5kJi6t+kShccXS8ae1APpYTW6yheSwk8Yi4=
+github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
+github.com/glycerine/go-unsnap-stream v0.0.0-20180323001048-9f0cb55181dd/go.mod h1:/20jfyN9Y5QPEAprSgKAUr+glWDY39ZiUEAYOEv5dsE=
+github.com/glycerine/goconvey v0.0.0-20190410193231-58a59202ab31/go.mod h1:Ogl1Tioa0aV7gstGFO7KhffUsb9M4ydbEbbxpcEDc24=
+github.com/go-chi/chi/v5 v5.0.0/go.mod h1:BBug9lr0cqtdAhsu6R4AAdvufI0/XBzAQSsUqJpoZOs=
+github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
+github.com/go-kit/kit v0.8.0 h1:Wz+5lgoB0kkuqLEc6NVmwRknTKP6dTGbSqvhZtBI/j0=
+github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
+github.com/go-logfmt/logfmt v0.4.0 h1:MP4Eh7ZCb31lleYCFuwm0oe4/YGak+5l1vA2NOE80nA=
+github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
+github.com/go-ole/go-ole v1.2.1 h1:2lOsA72HgjxAuMlKpFiCbHTvu44PIVkZ5hqm3RSdI/E=
+github.com/go-ole/go-ole v1.2.1/go.mod h1:7FAglXiTm7HKlQRDeOQ6ZNUHidzCWXuZWq/1dTyBNF8=
+github.com/go-openapi/jsonpointer v0.19.5/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg=
+github.com/go-openapi/swag v0.19.5/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh66Z9tfKk=
+github.com/go-sql-driver/mysql v1.4.1/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
+github.com/go-stack/stack v1.8.0 h1:5SgMzNM5HxrEjV0ww2lTmX6E2Izsfxas4+YHWRs3Lsk=
+github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/gofrs/uuid v3.3.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
+github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
+github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
+github.com/golang-jwt/jwt/v4 v4.3.0 h1:kHL1vqdqWNfATmA0FNMdmZNMyZI1U6O31X4rlIPoBog=
+github.com/golang-jwt/jwt/v4 v4.3.0/go.mod h1:/xlHOz8bRuivTWchD4jCa+NbatV+wEUSzwAxVc6locg=
+github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=
+github.com/golang/geo v0.0.0-20190916061304-5b978397cfec/go.mod h1:QZ0nwyI2jOfgRAoBvP+ab5aRr7c9x7lhGEJrKvBwjWI=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
+github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/golangci/lint-1 v0.0.0-20181222135242-d2cdd8c08219/go.mod h1:/X8TswGSh1pIozq4ZwCfxS0WA5JGXguxk94ar/4c87Y=
+github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/flatbuffers v1.11.0/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
+github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
+github.com/google/uuid v1.2.0 h1:qJYtXnJRWmpe7m/3XlyhrsLrEURqHRM2kxzoxXqyUDs=
+github.com/google/uuid v1.2.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
+github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
+github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
+github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
+github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc=
+github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/graph-gophers/graphql-go v1.3.0 h1:Eb9x/q6MFpCLz7jBCiP/WTxjSDrYLR1QY41SORZyNJ0=
+github.com/graph-gophers/graphql-go v1.3.0/go.mod h1:9CQHMSxwO4MprSdzoIEobiHpoLtHm77vfxsvsIN5Vuc=
+github.com/hashicorp/go-bexpr v0.1.10 h1:9kuI5PFotCboP3dkDYFr/wi0gg0QVbSNz5oFRpxn4uE=
+github.com/hashicorp/go-bexpr v0.1.10/go.mod h1:oxlubA2vC/gFVfX1A6JGp7ls7uCDlfJn732ehYYg+g0=
+github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d h1:dg1dEPuWpEqDnvIw251EVy4zlP8gWbsGj4BsUKCRpYs=
+github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
+github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao=
+github.com/holiman/bloomfilter/v2 v2.0.3/go.mod h1:zpoh+gs7qcpqrHr3dB55AMiJwo0iURXE7ZOP9L9hSkA=
+github.com/holiman/uint256 v1.2.0 h1:gpSYcPLWGv4sG43I2mVLiDZCNDh/EpGjSk8tmtxitHM=
+github.com/holiman/uint256 v1.2.0/go.mod h1:y4ga/t+u+Xwd7CpDgZESaRcWy0I7XMlTMA25ApIH5Jw=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/huin/goupnp v1.0.3 h1:N8No57ls+MnjlB+JPiCVSOyy/ot7MJTqlo7rn+NYSqQ=
+github.com/huin/goupnp v1.0.3/go.mod h1:ZxNlw5WqJj6wSsRK5+YfflQGXYfccj5VgQsMNixHM7Y=
+github.com/huin/goutil v0.0.0-20170803182201-1ca381bf3150/go.mod h1:PpLOETDnJ0o3iZrZfqZzyLl6l7F3c6L1oWn7OICBi6o=
+github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
+github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
+github.com/influxdata/flux v0.65.1/go.mod h1:J754/zds0vvpfwuq7Gc2wRdVwEodfpCFM7mYlOw2LqY=
+github.com/influxdata/influxdb v1.8.3 h1:WEypI1BQFTT4teLM+1qkEcvUi0dAvopAI/ir0vAiBg8=
+github.com/influxdata/influxdb v1.8.3/go.mod h1:JugdFhsvvI8gadxOI6noqNeeBHvWNTbfYGtiAn+2jhI=
+github.com/influxdata/influxdb-client-go/v2 v2.4.0 h1:HGBfZYStlx3Kqvsv1h2pJixbCl/jhnFtxpKFAv9Tu5k=
+github.com/influxdata/influxdb-client-go/v2 v2.4.0/go.mod h1:vLNHdxTJkIf2mSLvGrpj8TCcISApPoXkaxP8g9uRlW8=
+github.com/influxdata/influxql v1.1.1-0.20200828144457-65d3ef77d385/go.mod h1:gHp9y86a/pxhjJ+zMjNXiQAA197Xk9wLxaz+fGG+kWk=
+github.com/influxdata/line-protocol v0.0.0-20180522152040-32c6aa80de5e/go.mod h1:4kt73NQhadE3daL3WhR5EJ/J2ocX0PZzwxQ0gXJ7oFE=
+github.com/influxdata/line-protocol v0.0.0-20200327222509-2487e7298839/go.mod h1:xaLFMmpvUxqXtVkUJfg9QmT88cDaCJ3ZKgdZ78oO8Qo=
+github.com/influxdata/line-protocol v0.0.0-20210311194329-9aa0e372d097 h1:vilfsDSy7TDxedi9gyBkMvAirat/oRcL0lFdJBf6tdM=
+github.com/influxdata/line-protocol v0.0.0-20210311194329-9aa0e372d097/go.mod h1:xaLFMmpvUxqXtVkUJfg9QmT88cDaCJ3ZKgdZ78oO8Qo=
+github.com/influxdata/promql/v2 v2.12.0/go.mod h1:fxOPu+DY0bqCTCECchSRtWfc+0X19ybifQhZoQNF5D8=
+github.com/influxdata/roaring v0.4.13-0.20180809181101-fc520f41fab6/go.mod h1:bSgUQ7q5ZLSO+bKBGqJiCBGAl+9DxyW63zLTujjUlOE=
+github.com/influxdata/tdigest v0.0.0-20181121200506-bf2b5ad3c0a9/go.mod h1:Js0mqiSBE6Ffsg94weZZ2c+v/ciT8QRHFOap7EKDrR0=
+github.com/influxdata/usage-client v0.0.0-20160829180054-6d3895376368/go.mod h1:Wbbw6tYNvwa5dlB6304Sd+82Z3f7PmVZHVKU637d4po=
+github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus=
+github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc=
+github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
+github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
+github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
+github.com/jsternberg/zap-logfmt v1.0.0/go.mod h1:uvPs/4X51zdkcm5jXl5SYoN+4RK21K8mysFmDaM/h+o=
+github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
+github.com/julienschmidt/httprouter v1.2.0 h1:TDTW5Yz1mjftljbcKqRcrYhd4XeOoI98t+9HbQbYf7g=
+github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
+github.com/jung-kurt/gofpdf v1.0.3-0.20190309125859-24315acbbda5/go.mod h1:7Id9E/uU8ce6rXgefFLlgrJj/GYY22cpxn+r32jIOes=
+github.com/jwilder/encoding v0.0.0-20170811194829-b4e1701a28ef/go.mod h1:Ct9fl0F6iIOGgxJ5npU/IUOhOhqlVrGjyIZc8/MagT0=
+github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/klauspost/compress v1.4.0/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
+github.com/klauspost/cpuid v0.0.0-20170728055534-ae7887de9fa5/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
+github.com/klauspost/crc32 v0.0.0-20161016154125-cb6bfca970f6/go.mod h1:+ZoRqAPRLkC4NPOvfYeR5KNOrY6TD+/sAC3HXPZgDYg=
+github.com/klauspost/pgzip v1.0.2-0.20170402124221-0bf5dcad4ada/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs=
+github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515 h1:T+h1c/A9Gawja4Y9mFVWj2vyii2bbUNDw3kt9VxK2EY=
+github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
+github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/labstack/echo/v4 v4.2.1/go.mod h1:AA49e0DZ8kk5jTOOCKNuPR6oTnBS0dYiM4FW1e6jwpg=
+github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL7NoOu+k=
+github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
+github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
+github.com/mailru/easyjson v0.0.0-20190626092158-b2ccc519800e/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
+github.com/matryer/moq v0.0.0-20190312154309-6cfb0558e1bd/go.mod h1:9ELz6aaclSIGnZBoaSLZ3NAl1VTufbOrXBPvtcy6WiQ=
+github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
+github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
+github.com/mattn/go-colorable v0.1.7/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-colorable v0.1.8 h1:c1ghPdyEDarC70ftn0y+A/Ee++9zz8ljHG1b13eJ0s8=
+github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/mattn/go-isatty v0.0.9/go.mod h1:YNRxwqDuOph6SZLI9vUUz6OYw3QyUt7WiY2yME+cCiQ=
+github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/mattn/go-runewidth v0.0.3/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
+github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
+github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/mattn/go-sqlite3 v1.11.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
+github.com/mattn/go-tty v0.0.0-20180907095812-13ff1204f104/go.mod h1:XPvLUNfbS4fJH25nqRHfWLMa1ONC8Amw+mIA639KxkE=
+github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
+github.com/mitchellh/mapstructure v1.4.1 h1:CpVNEelQCZBooIPDn+AR3NpivK/TIKU8bDxdASFVQag=
+github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
+github.com/mitchellh/pointerstructure v1.2.0 h1:O+i9nHnXS3l/9Wu7r4NrEdwA2VFTicjUEN1uBnDo34A=
+github.com/mitchellh/pointerstructure v1.2.0/go.mod h1:BRAsLI5zgXmw97Lf6s25bs8ohIXc3tViBH44KcwB2g4=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/mschoch/smat v0.0.0-20160514031455-90eadee771ae/go.mod h1:qAyveg+e4CE+eKJXWVjKXM4ck2QobLqTDytGJbLLhJg=
+github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/nxadm/tail v1.4.4 h1:DQuhQpB1tVlglWS2hLQ5OV6B5r8aGxSrPc5Qo6uTN78=
+github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
+github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
+github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
+github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
+github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
+github.com/onsi/ginkgo v1.14.0 h1:2mOpI4JVVPBN+WQRa0WKH2eXR+Ey+uK4n7Zj0aYpIQA=
+github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY=
+github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
+github.com/onsi/gomega v1.10.1 h1:o0+MgICZLuZ7xjH7Vx6zS/zcu93/BEp1VwkIW1mEXCE=
+github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
+github.com/opentracing/opentracing-go v1.0.2/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
+github.com/opentracing/opentracing-go v1.0.3-0.20180606204148-bd9c31933947/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
+github.com/opentracing/opentracing-go v1.1.0 h1:pWlfV3Bxv7k65HYwkikxat0+s3pV4bsqf19k25Ur8rU=
+github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
+github.com/paulbellamy/ratecounter v0.2.0/go.mod h1:Hfx1hDpSGoqxkVVpBi/IlYD7kChlfo5C6hzIHwPqfFE=
+github.com/peterh/liner v1.0.1-0.20180619022028-8c1271fcf47f/go.mod h1:xIteQHvHuaLYG9IFj6mSxM0fCKrs34IrEQUhOYuGPHc=
+github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7 h1:oYW+YCJ1pachXTQmzR3rNLYGGz4g/UgFcjb28p/viDM=
+github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7/go.mod h1:CRroGNssyjTd/qIG2FyxByd2S8JEAZXBl4qUrZf8GS0=
+github.com/philhofer/fwd v1.0.0/go.mod h1:gk3iGcWd9+svBvR0sR+KPcfE+RNWozjowpeBVG3ZVNU=
+github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
+github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/term v0.0.0-20180730021639-bffc007b7fd5/go.mod h1:eCbImbZ95eXtAUIbLAuAVnBnwf83mjf6QIVH8SHYwqQ=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
+github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
+github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
+github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
+github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
+github.com/prometheus/common v0.6.0/go.mod h1:eBmuwkDJBwy6iBfxCBob6t6dR6ENT/y+J+Zk0j9GMYc=
+github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
+github.com/prometheus/tsdb v0.7.1 h1:YZcsG11NqnK4czYLrWd9mpEuAJIHVQLwdrleYfszMAA=
+github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
+github.com/retailnext/hllpp v1.0.1-0.20180308014038-101a6d2f8b52/go.mod h1:RDpi1RftBQPUCDRw6SmxeaREsAaRKnOclghuzp/WRzc=
+github.com/rjeczalik/notify v0.9.1 h1:CLCKso/QK1snAlnhNR/CNvNiFU2saUtjV0bx3EwNeCE=
+github.com/rjeczalik/notify v0.9.1/go.mod h1:rKwnCoCGeuQnwBtTSPL9Dad03Vh2n40ePRrjvIXnJho=
+github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
+github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik=
+github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
+github.com/segmentio/kafka-go v0.1.0/go.mod h1:X6itGqS9L4jDletMsxZ7Dz+JFWxM6JHfPOCvTvk+EJo=
+github.com/segmentio/kafka-go v0.2.0/go.mod h1:X6itGqS9L4jDletMsxZ7Dz+JFWxM6JHfPOCvTvk+EJo=
+github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
+github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible h1:Bn1aCHHRnjv4Bl16T8rcaFjYSrGrIZvpiGO6P3Q4GpU=
+github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
+github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
+github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
+github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
+github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
+github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
+github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
+github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
+github.com/status-im/keycard-go v0.0.0-20190316090335-8537d3370df4 h1:Gb2Tyox57NRNuZ2d3rmvB3pcmbu7O1RS3m8WRx7ilrg=
+github.com/status-im/keycard-go v0.0.0-20190316090335-8537d3370df4/go.mod h1:RZLeN1LMWmRsyYjvAu+I6Dm9QmlDaIIt+Y+4Kd7Tp+Q=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/testify v1.2.0/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.5 h1:s5PTfem8p8EbKQOctVV53k6jCJt3UX4IEJzwh+C324Q=
+github.com/stretchr/testify v1.7.5/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY=
+github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc=
+github.com/tinylib/msgp v1.0.2/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE=
+github.com/tklauser/go-sysconf v0.3.5 h1:uu3Xl4nkLzQfXNsWn15rPc/HQCJKObbt1dKJeWp3vU4=
+github.com/tklauser/go-sysconf v0.3.5/go.mod h1:MkWzOF4RMCshBAMXuhXJs64Rte09mITnppBXY/rYEFI=
+github.com/tklauser/numcpus v0.2.2 h1:oyhllyrScuYI6g+h/zUvNXNp1wy7x8qQy3t/piefldA=
+github.com/tklauser/numcpus v0.2.2/go.mod h1:x3qojaO3uyYt0i56EW/VUYs7uBvdl2fkfZFu0T9wgjM=
+github.com/tyler-smith/go-bip39 v1.0.1-0.20181017060643-dbb3b84ba2ef h1:wHSqTBrZW24CsNJDfeh9Ex6Pm0Rcpc7qrgKBiL44vF4=
+github.com/tyler-smith/go-bip39 v1.0.1-0.20181017060643-dbb3b84ba2ef/go.mod h1:sJ5fKU0s6JVwZjjcUEX2zFOnvq0ASQ2K9Zr6cf67kNs=
+github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
+github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8=
+github.com/valyala/fasttemplate v1.2.1/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
+github.com/willf/bitset v1.1.3/go.mod h1:RjeCKbqT1RxIR/KWY6phxZiaY1IyutSBfGjNPySAYV4=
+github.com/xlab/treeprint v0.0.0-20180616005107-d6fb6747feb6/go.mod h1:ce1O1j6UtZfjr22oyGxGLbauSBp2YVXpARAosm7dHBg=
+go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
+go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
+go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
+go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
+go.uber.org/zap v1.9.1/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
+golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200820211705-5c72a883971a/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519 h1:7I4JAnoQBe7ZtJcBaYHi5UtiO8tQHbUSXxL+pnGRANg=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190125153040-c74c464bbbf2/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
+golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
+golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
+golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs=
+golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
+golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
+golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
+golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
+golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
+golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
+golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
+golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f h1:OfiFi4JbukWwe3lzw+xunroH1mnC1e2Gy5cxNJApiSY=
+golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200107162124-548cf772de50/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200826173525-f9321e4c35a6/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210316164454-77fc1eacc6aa/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210324051608-47abb6519492/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20211019181941-9d821ace8654 h1:id054HUawV2/6IGm2IV8KZQjqtwAOo2CYlOToYqa0d0=
+golang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20201208040808-7e3f01d25324/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba h1:O8mE0/t419eoIwhTFpKVkHiTs/Igowgfkj25AcZrtiE=
+golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/tools v0.0.0-20180525024113-a5b4c53f6e8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190206041539-40960b6deb8e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
+golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200108203644-89082a384178/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gonum.org/v1/gonum v0.0.0-20180816165407-929014505bf4/go.mod h1:Y+Yx5eoAFn32cQvJDxZx5Dpnq+c3wtXuadVZAcxbbBo=
+gonum.org/v1/gonum v0.0.0-20181121035319-3f7ecaa7e8ca/go.mod h1:Y+Yx5eoAFn32cQvJDxZx5Dpnq+c3wtXuadVZAcxbbBo=
+gonum.org/v1/gonum v0.6.0/go.mod h1:9mxDZsDKxgMAuccQkewq682L+0eCu4dCN2yonUJTCLU=
+gonum.org/v1/netlib v0.0.0-20181029234149-ec6d1f5cefe6/go.mod h1:wa6Ws7BG/ESfp6dHfk7C6KdzKA7wR7u/rKwOGE66zvw=
+gonum.org/v1/netlib v0.0.0-20190313105609-8cb42192e0e0/go.mod h1:wa6Ws7BG/ESfp6dHfk7C6KdzKA7wR7u/rKwOGE66zvw=
+gonum.org/v1/plot v0.0.0-20190515093506-e2840ee46a6b/go.mod h1:Wt8AAjI+ypCyYX3nZBvf6cAIx93T+c/OS2HFAYskSZc=
+google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
+google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
+google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
+google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190716160619-c506a9f90610/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
+google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200108215221-bd8f9a0ef82f/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
+google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
+google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce h1:+JknDZhAj8YMt7GC73Ei8pv4MzjDUNPHgQWJdtMAaDU=
+gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce/go.mod h1:5AcXVHNjg+BDxry382+8OKon8SEWiKktQR07RKPsv1c=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/urfave/cli.v1 v1.20.0 h1:NdAVW6RYxDif9DhDHaAortIu956m2c0v+09AZBPTbE0=
+gopkg.in/urfave/cli.v1 v1.20.0/go.mod h1:vuBzUtMdQeixQj8LVd+/98pzhxNGQoyuPBlsXHOQNO0=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
+rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
+rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=