diff --git a/accounts/abi/abi.go b/accounts/abi/abi.go
deleted file mode 100644
index 4abf298068..0000000000
--- a/accounts/abi/abi.go
+++ /dev/null
@@ -1,311 +0,0 @@
-// 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"
- "math/big"
-
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
-)
-
-// 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
-
- // 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: %q - Bytes: %+v", data, data)
- }
- args = method.Outputs
- }
- if event, ok := abi.Events[name]; ok {
- args = event.Inputs
- }
- if args == nil {
- return nil, fmt.Errorf("abi: could not locate named method or event: %s", name)
- }
- 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
- }
- 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)
- 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)
- 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)
- 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())
-}
-
-// ErrorByID looks up an error by the 4-byte id,
-// returns nil if none found.
-func (abi *ABI) ErrorByID(sigdata [4]byte) (*Error, error) {
- for _, errABI := range abi.Errors {
- if bytes.Equal(errABI.ID[:4], sigdata[:]) {
- return &errABI, nil
- }
- }
- return nil, fmt.Errorf("no error with id: %#x", sigdata[:])
-}
-
-// 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]
-
-// panicSelector is a special function selector for panic reason unpacking.
-var panicSelector = crypto.Keccak256([]byte("Panic(uint256)"))[:4]
-
-// panicReasons map is for readable panic codes
-// see this linkage for the details
-// https://docs.soliditylang.org/en/v0.8.21/control-structures.html#panic-via-assert-and-error-via-require
-// the reason string list is copied from ether.js
-// https://github.com/ethers-io/ethers.js/blob/fa3a883ff7c88611ce766f58bdd4b8ac90814470/src.ts/abi/interface.ts#L207-L218
-var panicReasons = map[uint64]string{
- 0x00: "generic panic",
- 0x01: "assert(false)",
- 0x11: "arithmetic underflow or overflow",
- 0x12: "division or modulo by zero",
- 0x21: "enum overflow",
- 0x22: "invalid encoded storage byte array accessed",
- 0x31: "out-of-bounds array access; popping on an empty array",
- 0x32: "out-of-bounds access of an array or bytesN",
- 0x41: "out of memory",
- 0x51: "uninitialized function",
-}
-
-// 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 function
-// `Error(string)` or `Panic(uint256)`. 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")
- }
- switch {
- case bytes.Equal(data[:4], revertSelector):
- typ, err := NewType("string", "", nil)
- if err != nil {
- return "", err
- }
- unpacked, err := (Arguments{{Type: typ}}).Unpack(data[4:])
- if err != nil {
- return "", err
- }
- return unpacked[0].(string), nil
- case bytes.Equal(data[:4], panicSelector):
- typ, err := NewType("uint256", "", nil)
- if err != nil {
- return "", err
- }
- unpacked, err := (Arguments{{Type: typ}}).Unpack(data[4:])
- if err != nil {
- return "", err
- }
- pCode := unpacked[0].(*big.Int)
- // uint64 safety check for future
- // but the code is not bigger than MAX(uint64) now
- if pCode.IsUint64() {
- if reason, ok := panicReasons[pCode.Uint64()]; ok {
- return reason, nil
- }
- }
- return fmt.Sprintf("unknown panic code: %#x", pCode), nil
- default:
- return "", errors.New("invalid data for unpacking")
- }
-}
diff --git a/accounts/abi/abi_test.go b/accounts/abi/abi_test.go
deleted file mode 100644
index bc76df0dc2..0000000000
--- a/accounts/abi/abi_test.go
+++ /dev/null
@@ -1,1220 +0,0 @@
-// 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- // 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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)
- }
- }
-}
-
-func TestABI_ErrorByID(t *testing.T) {
- t.Parallel()
- abi, err := JSON(strings.NewReader(`[
- {"inputs":[{"internalType":"uint256","name":"x","type":"uint256"}],"name":"MyError1","type":"error"},
- {"inputs":[{"components":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"string","name":"b","type":"string"},{"internalType":"address","name":"c","type":"address"}],"internalType":"struct MyError.MyStruct","name":"x","type":"tuple"},{"internalType":"address","name":"y","type":"address"},{"components":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"string","name":"b","type":"string"},{"internalType":"address","name":"c","type":"address"}],"internalType":"struct MyError.MyStruct","name":"z","type":"tuple"}],"name":"MyError2","type":"error"},
- {"inputs":[{"internalType":"uint256[]","name":"x","type":"uint256[]"}],"name":"MyError3","type":"error"}
- ]`))
- if err != nil {
- t.Fatal(err)
- }
- for name, m := range abi.Errors {
- a := fmt.Sprintf("%v", &m)
- var id [4]byte
- copy(id[:], m.ID[:4])
- m2, err := abi.ErrorByID(id)
- if err != nil {
- t.Fatalf("Failed to look up ABI error: %v", err)
- }
- b := fmt.Sprintf("%v", m2)
- if a != b {
- t.Errorf("Error %v (id %x) not 'findable' by id in ABI", name, id)
- }
- }
- // test unsuccessful lookups
- if _, err = abi.ErrorByID([4]byte{}); err == nil {
- t.Error("Expected error: no error with this id")
- }
-}
-
-// 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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},
- {"4e487b710000000000000000000000000000000000000000000000000000000000000000", "generic panic", nil},
- {"4e487b7100000000000000000000000000000000000000000000000000000000000000ff", "unknown panic code: 0xff", nil},
- }
- for index, c := range cases {
- index, c := index, c
- t.Run(fmt.Sprintf("case %d", index), func(t *testing.T) {
- t.Parallel()
- 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/accounts/abi/abifuzzer_test.go b/accounts/abi/abifuzzer_test.go
deleted file mode 100644
index dbf6ab6c54..0000000000
--- a/accounts/abi/abifuzzer_test.go
+++ /dev/null
@@ -1,179 +0,0 @@
-// 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 (
- "fmt"
- "reflect"
- "strings"
- "testing"
-
- fuzz "github.com/google/gofuzz"
-)
-
-// TestReplicate can be used to replicate crashers from the fuzzing tests.
-// Just replace testString with the data in .quoted
-func TestReplicate(t *testing.T) {
- t.Parallel()
- //t.Skip("Test only useful for reproducing issues")
- fuzzAbi([]byte("\x20\x20\x20\x20\x20\x20\x20\x20\x80\x00\x00\x00\x20\x20\x20\x20\x00"))
- //fuzzAbi([]byte("asdfasdfkadsf;lasdf;lasd;lfk"))
-}
-
-// FuzzABI is the main entrypoint for fuzzing
-func FuzzABI(f *testing.F) {
- f.Fuzz(func(t *testing.T, data []byte) {
- fuzzAbi(data)
- })
-}
-
-var (
- names = []string{"_name", "name", "NAME", "name_", "__", "_name_", "n"}
- stateMut = []string{"pure", "view", "payable"}
- pays = []string{"true", "false"}
- vNames = []string{"a", "b", "c", "d", "e", "f", "g"}
- varNames = append(vNames, names...)
- varTypes = []string{"bool", "address", "bytes", "string",
- "uint8", "int8", "uint8", "int8", "uint16", "int16",
- "uint24", "int24", "uint32", "int32", "uint40", "int40", "uint48", "int48", "uint56", "int56",
- "uint64", "int64", "uint72", "int72", "uint80", "int80", "uint88", "int88", "uint96", "int96",
- "uint104", "int104", "uint112", "int112", "uint120", "int120", "uint128", "int128", "uint136", "int136",
- "uint144", "int144", "uint152", "int152", "uint160", "int160", "uint168", "int168", "uint176", "int176",
- "uint184", "int184", "uint192", "int192", "uint200", "int200", "uint208", "int208", "uint216", "int216",
- "uint224", "int224", "uint232", "int232", "uint240", "int240", "uint248", "int248", "uint256", "int256",
- "bytes1", "bytes2", "bytes3", "bytes4", "bytes5", "bytes6", "bytes7", "bytes8", "bytes9", "bytes10", "bytes11",
- "bytes12", "bytes13", "bytes14", "bytes15", "bytes16", "bytes17", "bytes18", "bytes19", "bytes20", "bytes21",
- "bytes22", "bytes23", "bytes24", "bytes25", "bytes26", "bytes27", "bytes28", "bytes29", "bytes30", "bytes31",
- "bytes32", "bytes"}
-)
-
-func unpackPack(abi ABI, method string, input []byte) ([]interface{}, bool) {
- if out, err := abi.Unpack(method, input); err == nil {
- _, err := abi.Pack(method, out...)
- if err != nil {
- // We have some false positives as we can unpack these type successfully, but not pack them
- if err.Error() == "abi: cannot use []uint8 as type [0]int8 as argument" ||
- err.Error() == "abi: cannot use uint8 as type int8 as argument" {
- return out, false
- }
- panic(err)
- }
- return out, true
- }
- return nil, false
-}
-
-func packUnpack(abi ABI, method string, input *[]interface{}) bool {
- if packed, err := abi.Pack(method, input); err == nil {
- outptr := reflect.New(reflect.TypeOf(input))
- err := abi.UnpackIntoInterface(outptr.Interface(), method, packed)
- if err != nil {
- panic(err)
- }
- out := outptr.Elem().Interface()
- if !reflect.DeepEqual(input, out) {
- panic(fmt.Sprintf("unpackPack is not equal, \ninput : %x\noutput: %x", input, out))
- }
- return true
- }
- return false
-}
-
-type arg struct {
- name string
- typ string
-}
-
-func createABI(name string, stateMutability, payable *string, inputs []arg) (ABI, error) {
- sig := fmt.Sprintf(`[{ "type" : "function", "name" : "%v" `, name)
- if stateMutability != nil {
- sig += fmt.Sprintf(`, "stateMutability": "%v" `, *stateMutability)
- }
- if payable != nil {
- sig += fmt.Sprintf(`, "payable": %v `, *payable)
- }
- if len(inputs) > 0 {
- sig += `, "inputs" : [ {`
- for i, inp := range inputs {
- sig += fmt.Sprintf(`"name" : "%v", "type" : "%v" `, inp.name, inp.typ)
- if i+1 < len(inputs) {
- sig += ","
- }
- }
- sig += "} ]"
- sig += `, "outputs" : [ {`
- for i, inp := range inputs {
- sig += fmt.Sprintf(`"name" : "%v", "type" : "%v" `, inp.name, inp.typ)
- if i+1 < len(inputs) {
- sig += ","
- }
- }
- sig += "} ]"
- }
- sig += `}]`
- //fmt.Printf("sig: %s\n", sig)
- return JSON(strings.NewReader(sig))
-}
-
-func fuzzAbi(input []byte) {
- var (
- fuzzer = fuzz.NewFromGoFuzz(input)
- name = oneOf(fuzzer, names)
- stateM = oneOfOrNil(fuzzer, stateMut)
- payable = oneOfOrNil(fuzzer, pays)
- arguments []arg
- )
- for i := 0; i < upTo(fuzzer, 10); i++ {
- argName := oneOf(fuzzer, varNames)
- argTyp := oneOf(fuzzer, varTypes)
- switch upTo(fuzzer, 10) {
- case 0: // 10% chance to make it a slice
- argTyp += "[]"
- case 1: // 10% chance to make it an array
- argTyp += fmt.Sprintf("[%d]", 1+upTo(fuzzer, 30))
- default:
- }
- arguments = append(arguments, arg{name: argName, typ: argTyp})
- }
- abi, err := createABI(name, stateM, payable, arguments)
- if err != nil {
- //fmt.Printf("err: %v\n", err)
- panic(err)
- }
- structs, _ := unpackPack(abi, name, input)
- _ = packUnpack(abi, name, &structs)
-}
-
-func upTo(fuzzer *fuzz.Fuzzer, max int) int {
- var i int
- fuzzer.Fuzz(&i)
- if i < 0 {
- return (-1 - i) % max
- }
- return i % max
-}
-
-func oneOf(fuzzer *fuzz.Fuzzer, options []string) string {
- return options[upTo(fuzzer, len(options))]
-}
-
-func oneOfOrNil(fuzzer *fuzz.Fuzzer, options []string) *string {
- if i := upTo(fuzzer, len(options)+1); i < len(options) {
- return &options[i]
- }
- return nil
-}
diff --git a/accounts/abi/argument.go b/accounts/abi/argument.go
deleted file mode 100644
index fa5461895a..0000000000
--- a/accounts/abi/argument.go
+++ /dev/null
@@ -1,273 +0,0 @@
-// 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"
- "errors"
- "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
-}
-
-type Arguments []Argument
-
-type ArgumentMarshaling struct {
- Name string
- Type string
- InternalType string
- Components []ArgumentMarshaling
- Indexed bool
-}
-
-// 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
-
- 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, errors.New("abi: attempting to unmarshal 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 errors.New("abi: cannot unpack into a nil map")
- }
- if len(data) == 0 {
- if len(arguments.NonIndexed()) != 0 {
- return errors.New("abi: attempting to unmarshal 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 errors.New("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 err != nil {
- return nil, err
- }
- 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
- }
- 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/accounts/abi/bind/auth.go b/accounts/abi/bind/auth.go
deleted file mode 100644
index 0740c69510..0000000000
--- a/accounts/abi/bind/auth.go
+++ /dev/null
@@ -1,179 +0,0 @@
-// 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
-// a 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
-// a 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/accounts/abi/bind/backend.go b/accounts/abi/bind/backend.go
deleted file mode 100644
index 2e45e86ae2..0000000000
--- a/accounts/abi/bind/backend.go
+++ /dev/null
@@ -1,141 +0,0 @@
-// 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. self-destructed).
- 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")
-
- // ErrNoBlockHashState is raised when attempting to perform a block hash action
- // on a backend that doesn't implement BlockHashContractCaller.
- ErrNoBlockHashState = errors.New("backend does not support block hash 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)
-}
-
-// BlockHashContractCaller defines methods to perform contract calls on a specific block hash.
-// Call will try to discover this interface when access to a block by hash is requested.
-// If the backend does not support the block hash state, Call returns ErrNoBlockHashState.
-type BlockHashContractCaller interface {
- // CodeAtHash returns the code of the given account in the state at the specified block hash.
- CodeAtHash(ctx context.Context, contract common.Address, blockHash common.Hash) ([]byte, error)
-
- // CallContractAtHash executes an Ethereum contract call against the state at the specified block hash.
- CallContractAtHash(ctx context.Context, call ethereum.CallMsg, blockHash common.Hash) ([]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/accounts/abi/bind/backends/simulated.go b/accounts/abi/bind/backends/simulated.go
deleted file mode 100644
index 2faf274dbd..0000000000
--- a/accounts/abi/bind/backends/simulated.go
+++ /dev/null
@@ -1,975 +0,0 @@
-// 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")
- errBlockHashUnsupported = errors.New("simulatedBackend cannot access blocks by hash 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 // for filtering log events live
- filterSystem *filters.FilterSystem // for filtering database logs
-
- 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,
- }
- blockchain, _ := core.NewBlockChain(database, nil, &genesis, nil, ethash.NewFaker(), vm.Config{}, nil, nil)
-
- backend := &SimulatedBackend{
- database: database,
- blockchain: blockchain,
- config: genesis.Config,
- }
-
- filterBackend := &filterBackend{database, blockchain, backend}
- backend.filterSystem = filters.NewFilterSystem(filterBackend, filters.Config{})
- backend.events = filters.NewEventSystem(backend.filterSystem, false)
-
- header := backend.blockchain.CurrentBlock()
- block := backend.blockchain.GetBlock(header.Hash(), header.Number.Uint64())
-
- backend.rollback(block)
- 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() common.Hash {
- 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
- }
- blockHash := b.pendingBlock.Hash()
-
- // Using the last inserted block here makes it possible to build on a side
- // chain after a fork.
- b.rollback(b.pendingBlock)
-
- return blockHash
-}
-
-// Rollback aborts all pending transactions, reverting to the last committed state.
-func (b *SimulatedBackend) Rollback() {
- b.mu.Lock()
- defer b.mu.Unlock()
-
- header := b.blockchain.CurrentBlock()
- block := b.blockchain.GetBlock(header.Hash(), header.Number.Uint64())
-
- b.rollback(block)
-}
-
-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
-}
-
-// CodeAtHash returns the code associated with a certain account in the blockchain.
-func (b *SimulatedBackend) CodeAtHash(ctx context.Context, contract common.Address, blockHash common.Hash) ([]byte, error) {
- b.mu.Lock()
- defer b.mu.Unlock()
-
- header, err := b.headerByHash(blockHash)
- if err != nil {
- return nil, err
- }
-
- stateDB, err := b.blockchain.StateAt(header.Root)
- 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.blockByHash(ctx, b.blockchain.CurrentBlock().Hash())
- }
-
- 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()
- return b.headerByHash(hash)
-}
-
-// headerByHash retrieves a header from the database by hash without Lock.
-func (b *SimulatedBackend) headerByHash(hash common.Hash) (*types.Header, error) {
- 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
- }
- return b.callContractAtHead(ctx, call)
-}
-
-// CallContractAtHash executes a contract call on a specific block hash.
-func (b *SimulatedBackend) CallContractAtHash(ctx context.Context, call ethereum.CallMsg, blockHash common.Hash) ([]byte, error) {
- b.mu.Lock()
- defer b.mu.Unlock()
-
- if blockHash != b.blockchain.CurrentBlock().Hash() {
- return nil, errBlockHashUnsupported
- }
- return b.callContractAtHead(ctx, call)
-}
-
-// callContractAtHead executes a contract call against the latest block state.
-func (b *SimulatedBackend) callContractAtHead(ctx context.Context, call ethereum.CallMsg) ([]byte, error) {
- 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.Header(), 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, core.ErrInsufficientFundsForTransfer
- }
- 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.Header(), 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 && !errors.Is(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, header *types.Header, 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")
- }
- if !b.blockchain.Config().IsLondon(header.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 fields (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, header.BaseFee), call.GasFeeCap)
- }
- }
- }
- // Ensure message is initialized properly.
- if call.Gas == 0 {
- call.Gas = 10 * header.GasLimit
- }
- 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 := &core.Message{
- From: call.From,
- To: call.To,
- Value: call.Value,
- GasLimit: call.Gas,
- GasPrice: call.GasPrice,
- GasFeeCap: call.GasFeeCap,
- GasTipCap: call.GasTipCap,
- Data: call.Data,
- AccessList: call.AccessList,
- SkipAccountChecks: true,
- }
-
- // Create a new environment which holds all relevant information
- // about the transaction and calling mechanisms.
- txContext := core.NewEVMTxContext(msg)
- evmContext := core.NewEVMBlockContext(header, b.blockchain, nil)
- vmEnv := vm.NewEVM(evmContext, txContext, stateDB, b.config, vm.Config{NoBaseFee: true})
- gasPool := new(core.GasPool).AddGas(math.MaxUint64)
-
- return core.ApplyMessage(vmEnv, msg, gasPool)
-}
-
-// 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 errors.New("could not fetch parent")
- }
- // Check transaction validity
- signer := types.MakeSigner(b.blockchain.Config(), block.Number(), block.Time())
- 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, err := b.blockchain.State()
- if err != nil {
- return err
- }
- 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 = b.filterSystem.NewBlockFilter(*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 = b.filterSystem.NewRangeFilter(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")
- }
- // Get the last block
- block := b.blockchain.GetBlockByHash(b.pendingBlock.ParentHash())
- if block == nil {
- return errors.New("could not find parent")
- }
-
- blocks, _ := core.GenerateChain(b.config, block, ethash.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) {
- block.OffsetTime(int64(adjustment.Seconds()))
- })
- stateDB, err := b.blockchain.State()
- if err != nil {
- return err
- }
- 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
-}
-
-// 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, number rpc.BlockNumber) (*types.Header, error) {
- switch number {
- case rpc.PendingBlockNumber:
- if block := fb.backend.pendingBlock; block != nil {
- return block.Header(), nil
- }
- return nil, nil
- case rpc.LatestBlockNumber:
- return fb.bc.CurrentHeader(), nil
- case rpc.FinalizedBlockNumber:
- return fb.bc.CurrentFinalBlock(), nil
- case rpc.SafeBlockNumber:
- return fb.bc.CurrentSafeBlock(), nil
- default:
- return fb.bc.GetHeaderByNumber(uint64(number.Int64())), nil
- }
-}
-
-func (fb *filterBackend) HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error) {
- return fb.bc.GetHeaderByHash(hash), nil
-}
-
-func (fb *filterBackend) GetBody(ctx context.Context, hash common.Hash, number rpc.BlockNumber) (*types.Body, error) {
- if body := fb.bc.GetBody(hash); body != nil {
- return body, nil
- }
- return nil, errors.New("block body not found")
-}
-
-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
- }
- header := rawdb.ReadHeader(fb.db, hash, *number)
- if header == nil {
- return nil, nil
- }
- return rawdb.ReadReceipts(fb.db, hash, *number, header.Time, fb.bc.Config()), nil
-}
-
-func (fb *filterBackend) GetLogs(ctx context.Context, hash common.Hash, number uint64) ([][]*types.Log, error) {
- logs := rawdb.ReadLogs(fb.db, hash, number)
- 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 (fb *filterBackend) ChainConfig() *params.ChainConfig {
- panic("not supported")
-}
-
-func (fb *filterBackend) CurrentHeader() *types.Header {
- panic("not supported")
-}
-
-func nullSubscription() event.Subscription {
- return event.NewSubscription(func(quit <-chan struct{}) error {
- <-quit
- return nil
- })
-}
diff --git a/accounts/abi/bind/backends/simulated_test.go b/accounts/abi/bind/backends/simulated_test.go
deleted file mode 100644
index a2acf7ead5..0000000000
--- a/accounts/abi/bind/backends/simulated_test.go
+++ /dev/null
@@ -1,1483 +0,0 @@
-// 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
- sim := simTestBackend(testAddr)
- defer sim.blockchain.Stop()
-
- // 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- /*
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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)
- }
-}
-
-func TestCodeAtHash(t *testing.T) {
- t.Parallel()
- testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
- sim := simTestBackend(testAddr)
- defer sim.Close()
- bgCtx := context.Background()
- code, err := sim.CodeAtHash(bgCtx, testAddr, sim.Blockchain().CurrentHeader().Hash())
- 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)
- }
-
- blockHash := sim.Commit()
- code, err = sim.CodeAtHash(bgCtx, contractAddr, blockHash)
- 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) {
- t.Parallel()
- 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))
- }
-
- blockHash := 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))
- }
-
- // make sure you can call the contract by hash
- res, err = sim.CallContractAtHash(bgCtx, ethereum.CallMsg{
- From: testAddr,
- To: &addr,
- Data: input,
- }, blockHash)
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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().Number.Uint64() != 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().Number.Uint64() != 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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)
- }
-}
-
-func TestCommitReturnValue(t *testing.T) {
- t.Parallel()
- testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
- sim := simTestBackend(testAddr)
- defer sim.Close()
-
- startBlockHeight := sim.blockchain.CurrentBlock().Number.Uint64()
-
- // Test if Commit returns the correct block hash
- h1 := sim.Commit()
- if h1 != sim.blockchain.CurrentBlock().Hash() {
- t.Error("Commit did not return the hash of the last block.")
- }
-
- // Create a block in the original chain (containing a transaction to force different block hashes)
- 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)
- h2 := sim.Commit()
-
- // Create another block in the original chain
- sim.Commit()
-
- // Fork at the first bock
- if err := sim.Fork(context.Background(), h1); err != nil {
- t.Errorf("forking: %v", err)
- }
-
- // Test if Commit returns the correct block hash after the reorg
- h2fork := sim.Commit()
- if h2 == h2fork {
- t.Error("The block in the fork and the original block are the same block!")
- }
- if sim.blockchain.GetHeader(h2fork, startBlockHeight+2) == nil {
- t.Error("Could not retrieve the just created block (side-chain)")
- }
-}
-
-// TestAdjustTimeAfterFork ensures that after a fork, AdjustTime uses the pending fork
-// block's parent rather than the canonical head's parent.
-func TestAdjustTimeAfterFork(t *testing.T) {
- t.Parallel()
- testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
- sim := simTestBackend(testAddr)
- defer sim.Close()
-
- sim.Commit() // h1
- h1 := sim.blockchain.CurrentHeader().Hash()
- sim.Commit() // h2
- sim.Fork(context.Background(), h1)
- sim.AdjustTime(1 * time.Second)
- sim.Commit()
-
- head := sim.blockchain.CurrentHeader()
- if head.Number == common.Big2 && head.ParentHash != h1 {
- t.Errorf("failed to build block on fork")
- }
-}
diff --git a/accounts/abi/bind/base.go b/accounts/abi/bind/base.go
deleted file mode 100644
index 96d284cdcc..0000000000
--- a/accounts/abi/bind/base.go
+++ /dev/null
@@ -1,565 +0,0 @@
-// 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/accounts/abi"
- "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"
-)
-
-const basefeeWiggleMultiplier = 2
-
-var (
- errNoEventSignature = errors.New("no event signature")
- errEventSignatureMismatch = errors.New("event signature mismatch")
-)
-
-// 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
- BlockHash common.Hash // Optional the block hash 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 if opts.BlockHash != (common.Hash{}) {
- bh, ok := c.caller.(BlockHashContractCaller)
- if !ok {
- return ErrNoBlockHashState
- }
- output, err = bh.CallContractAtHash(ctx, msg, opts.BlockHash)
- 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 = bh.CodeAtHash(ctx, c.address, opts.BlockHash); 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 whether 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 whether 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(basefeeWiggleMultiplier)),
- )
- }
- 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 if opts.GasFeeCap != nil && opts.GasTipCap != nil {
- rawTx, err = c.createDynamicTx(opts, contract, input, nil)
- } 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 {
- // Anonymous events are not supported.
- if len(log.Topics) == 0 {
- return errNoEventSignature
- }
- if log.Topics[0] != c.abi.Events[event].ID {
- return errEventSignatureMismatch
- }
- 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 {
- // Anonymous events are not supported.
- if len(log.Topics) == 0 {
- return errNoEventSignature
- }
- if log.Topics[0] != c.abi.Events[event].ID {
- return errEventSignatureMismatch
- }
- 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/accounts/abi/bind/base_test.go b/accounts/abi/bind/base_test.go
deleted file mode 100644
index f7eb7d14d3..0000000000
--- a/accounts/abi/bind/base_test.go
+++ /dev/null
@@ -1,589 +0,0 @@
-// 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
-}
-
-type mockBlockHashCaller struct {
- *mockCaller
- codeAtHashBytes []byte
- codeAtHashErr error
- codeAtHashCalled bool
- callContractAtHashCalled bool
- callContractAtHashBytes []byte
- callContractAtHashErr error
-}
-
-func (mc *mockBlockHashCaller) CodeAtHash(ctx context.Context, contract common.Address, hash common.Hash) ([]byte, error) {
- mc.codeAtHashCalled = true
- return mc.codeAtHashBytes, mc.codeAtHashErr
-}
-
-func (mc *mockBlockHashCaller) CallContractAtHash(ctx context.Context, call ethereum.CallMsg, hash common.Hash) ([]byte, error) {
- mc.callContractAtHashCalled = true
- return mc.callContractAtHashBytes, mc.callContractAtHashErr
-}
-
-func TestPassingBlockNumber(t *testing.T) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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 TestUnpackAnonymousLogIntoMap(t *testing.T) {
- t.Parallel()
- mockLog := newMockLog(nil, common.HexToHash("0x0"))
-
- abiString := `[{"anonymous":false,"inputs":[{"indexed":false,"name":"amount","type":"uint256"}],"name":"received","type":"event"}]`
- parsedAbi, _ := abi.JSON(strings.NewReader(abiString))
- bc := bind.NewBoundContract(common.HexToAddress("0x0"), parsedAbi, nil, nil, nil)
-
- var received map[string]interface{}
- err := bc.UnpackLogIntoMap(received, "received", mockLog)
- if err == nil {
- t.Error("unpacking anonymous event is not supported")
- }
- if err.Error() != "no event signature" {
- t.Errorf("expected error 'no event signature', got '%s'", err)
- }
-}
-
-func TestUnpackIndexedSliceTyLogIntoMap(t *testing.T) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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: "ok hash",
- mc: &mockBlockHashCaller{
- codeAtHashBytes: []byte{0},
- },
- opts: &bind.CallOpts{
- BlockHash: common.Hash{0xaa},
- },
- 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: "interface error, blockHash but not a BlockHashContractCaller",
- mc: new(mockCaller),
- opts: &bind.CallOpts{
- BlockHash: common.Hash{0xaa},
- },
- method: method,
- wantErrExact: bind.ErrNoBlockHashState,
- }, {
- 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: "call contract at hash error",
- mc: &mockBlockHashCaller{
- callContractAtHashErr: context.DeadlineExceeded,
- },
- opts: &bind.CallOpts{
- BlockHash: common.Hash{0xaa},
- },
- method: method,
- wantErrExact: context.DeadlineExceeded,
- }, {
- name: "code at error",
- mc: &mockBlockHashCaller{
- codeAtHashErr: errors.New(""),
- },
- opts: &bind.CallOpts{
- BlockHash: common.Hash{0xaa},
- },
- method: method,
- wantErr: true,
- }, {
- name: "no code at hash",
- mc: new(mockBlockHashCaller),
- opts: &bind.CallOpts{
- BlockHash: common.Hash{0xaa},
- },
- 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) {
- t.Parallel()
- 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/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go
deleted file mode 100644
index e902345f09..0000000000
--- a/accounts/abi/bind/bind.go
+++ /dev/null
@@ -1,496 +0,0 @@
-// 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"
- "fmt"
- "go/format"
- "regexp"
- "strings"
- "text/template"
- "unicode"
-
- "github.com/ethereum/go-ethereum/accounts/abi"
- "github.com/ethereum/go-ethereum/log"
-)
-
-// Lang is a target programming language selector to generate bindings for.
-type Lang int
-
-const (
- LangGo Lang = iota
-)
-
-func isKeyWord(arg string) bool {
- switch arg {
- case "break":
- case "case":
- case "chan":
- case "const":
- case "continue":
- case "default":
- case "defer":
- case "else":
- case "fallthrough":
- case "for":
- case "func":
- case "go":
- case "goto":
- case "if":
- case "import":
- case "interface":
- case "iota":
- case "map":
- case "make":
- case "new":
- case "package":
- case "range":
- case "return":
- case "select":
- case "struct":
- case "switch":
- case "type":
- case "var":
- default:
- return false
- }
-
- return true
-}
-
-// 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 as 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
- }
- // Name shouldn't start with a digit. It will make the generated code invalid.
- if len(normalizedName) > 0 && unicode.IsDigit(rune(normalizedName[0])) {
- normalizedName = fmt.Sprintf("M%s", normalizedName)
- normalizedName = abi.ResolveNameConflict(normalizedName, func(name string) bool {
- _, ok := identifiers[name]
- return ok
- })
- }
- 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 == "" || isKeyWord(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))
- // Name shouldn't start with a digit. It will make the generated code invalid.
- if len(normalizedName) > 0 && unicode.IsDigit(rune(normalizedName[0])) {
- normalizedName = fmt.Sprintf("E%s", normalizedName)
- normalizedName = abi.ResolveNameConflict(normalizedName, func(name string) bool {
- _, ok := eventIdentifiers[name]
- return ok
- })
- }
- 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 == "" || isKeyWord(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}
- }
- 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)
- }
- return string(code), 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,
-}
-
-// 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)
- }
-}
-
-// 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,
-}
-
-// 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
-}
-
-// 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,
-}
-
-// 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)
- }
-}
-
-// 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") },
-}
-
-// 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,
-}
-
-// 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/accounts/abi/bind/bind_test.go b/accounts/abi/bind/bind_test.go
deleted file mode 100644
index a5f7afa73c..0000000000
--- a/accounts/abi/bind/bind_test.go
+++ /dev/null
@@ -1,2141 +0,0 @@
-// 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 retriever 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)
- }
- `,
- },
- {
- name: "RangeKeyword",
- contract: `
- // SPDX-License-Identifier: GPL-3.0
- pragma solidity >=0.4.22 <0.9.0;
- contract keywordcontract {
- function functionWithKeywordParameter(range uint256) public pure {}
- }
- `,
- bytecode: []string{"0x608060405234801561001057600080fd5b5060dc8061001f6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063527a119f14602d575b600080fd5b60436004803603810190603f9190605b565b6045565b005b50565b6000813590506055816092565b92915050565b600060208284031215606e57606d608d565b5b6000607a848285016048565b91505092915050565b6000819050919050565b600080fd5b6099816083565b811460a357600080fd5b5056fea2646970667358221220d4f4525e2615516394055d369fb17df41c359e5e962734f27fd683ea81fd9db164736f6c63430008070033"},
- abi: []string{`[{"inputs":[{"internalType":"uint256","name":"range","type":"uint256"}],"name":"functionWithKeywordParameter","outputs":[],"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)
- )
- _, tx, _, err := DeployRangeKeyword(user, sim)
- if err != nil {
- t.Fatalf("error deploying contract: %v", err)
- }
- sim.Commit()
-
- if _, err = bind.WaitDeployed(nil, sim, tx); err != nil {
- t.Errorf("error deploying the contract: %v", err)
- }
- `,
- }, {
- name: "NumericMethodName",
- contract: `
- // SPDX-License-Identifier: GPL-3.0
- pragma solidity >=0.4.22 <0.9.0;
-
- contract NumericMethodName {
- event _1TestEvent(address _param);
- function _1test() public pure {}
- function __1test() public pure {}
- function __2test() public pure {}
- }
- `,
- bytecode: []string{"0x6080604052348015600f57600080fd5b5060958061001e6000396000f3fe6080604052348015600f57600080fd5b5060043610603c5760003560e01c80639d993132146041578063d02767c7146049578063ffa02795146051575b600080fd5b60476059565b005b604f605b565b005b6057605d565b005b565b565b56fea26469706673582212200382ca602dff96a7e2ba54657985e2b4ac423a56abe4a1f0667bc635c4d4371f64736f6c63430008110033"},
- abi: []string{`[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_param","type":"address"}],"name":"_1TestEvent","type":"event"},{"inputs":[],"name":"_1test","outputs":[],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"__1test","outputs":[],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"__2test","outputs":[],"stateMutability":"pure","type":"function"}]`},
- imports: `
- "github.com/ethereum/go-ethereum/common"
- `,
- tester: `
- if b, err := NewNumericMethodName(common.Address{}, nil); b == nil || err != nil {
- t.Fatalf("combined binding (%v) nil or error (%v) not nil", b, nil)
- }
-`,
- },
-}
-
-// Tests that packages generated by the binder can be successfully compiled and
-// the requested tester run against it.
-func TestGolangBindings(t *testing.T) {
- t.Parallel()
- // 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)
- }
-}
diff --git a/accounts/abi/bind/template.go b/accounts/abi/bind/template.go
deleted file mode 100644
index 95dc13cc18..0000000000
--- a/accounts/abi/bind/template.go
+++ /dev/null
@@ -1,571 +0,0 @@
-// 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 "github.com/ethereum/go-ethereum/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,
-}
-
-// 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
- _ = abi.ConvertType
-)
-
-{{$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 := {{.Type}}MetaData.GetAbi()
- 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}}
-`
diff --git a/accounts/abi/bind/util.go b/accounts/abi/bind/util.go
deleted file mode 100644
index b931fbb04d..0000000000
--- a/accounts/abi/bind/util.go
+++ /dev/null
@@ -1,79 +0,0 @@
-// 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/accounts/abi/bind/util_test.go b/accounts/abi/bind/util_test.go
deleted file mode 100644
index 826426632c..0000000000
--- a/accounts/abi/bind/util_test.go
+++ /dev/null
@@ -1,142 +0,0 @@
-// 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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()
- notContractCreation := errors.New("tx is not contract creation")
- if _, err := bind.WaitDeployed(ctx, backend, tx); err.Error() != notContractCreation.Error() {
- t.Errorf("error mismatch: want %q, got %q, ", notContractCreation, 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 mismatch: want %q, got %q, ", contextCanceled, err)
- }
- }()
-
- backend.SendTransaction(ctx, tx)
- cancel()
-}
diff --git a/accounts/abi/doc.go b/accounts/abi/doc.go
deleted file mode 100644
index 8242068582..0000000000
--- a/accounts/abi/doc.go
+++ /dev/null
@@ -1,26 +0,0 @@
-// 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/accounts/abi/error.go b/accounts/abi/error.go
deleted file mode 100644
index 8e50112ec5..0000000000
--- a/accounts/abi/error.go
+++ /dev/null
@@ -1,92 +0,0 @@
-// 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"
- "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 "", fmt.Errorf("insufficient data for unpacking: have %d, want at least 4", len(data))
- }
- if !bytes.Equal(data[:4], e.ID[:4]) {
- return "", fmt.Errorf("invalid identifier, have %#x want %#x", data[:4], e.ID[:4])
- }
- return e.Inputs.Unpack(data[4:])
-}
diff --git a/accounts/abi/error_handling.go b/accounts/abi/error_handling.go
deleted file mode 100644
index c106e9ac43..0000000000
--- a/accounts/abi/error_handling.go
+++ /dev/null
@@ -1,89 +0,0 @@
-// 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")
- errBadUint8 = errors.New("abi: improperly encoded uint8 value")
- errBadUint16 = errors.New("abi: improperly encoded uint16 value")
- errBadUint32 = errors.New("abi: improperly encoded uint32 value")
- errBadUint64 = errors.New("abi: improperly encoded uint64 value")
- errBadInt8 = errors.New("abi: improperly encoded int8 value")
- errBadInt16 = errors.New("abi: improperly encoded int16 value")
- errBadInt32 = errors.New("abi: improperly encoded int32 value")
- errBadInt64 = errors.New("abi: improperly encoded int64 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/accounts/abi/event.go b/accounts/abi/event.go
deleted file mode 100644
index f9457b86af..0000000000
--- a/accounts/abi/event.go
+++ /dev/null
@@ -1,103 +0,0 @@
-// 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) 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, ","))
- 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
-}
diff --git a/accounts/abi/event_test.go b/accounts/abi/event_test.go
deleted file mode 100644
index fffe28ea63..0000000000
--- a/accounts/abi/event_test.go
+++ /dev/null
@@ -1,395 +0,0 @@
-// 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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/accounts/abi/method.go b/accounts/abi/method.go
deleted file mode 100644
index c5a1a71f47..0000000000
--- a/accounts/abi/method.go
+++ /dev/null
@@ -1,166 +0,0 @@
-// 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]
- }
- identity := fmt.Sprintf("function %v", rawName)
- switch funType {
- case Fallback:
- identity = "fallback"
- case Receive:
- identity = "receive"
- case Constructor:
- identity = "constructor"
- }
- var str string
- // Extract meaningful state mutability of solidity method.
- // If it's empty string or default value "nonpayable", never print it.
- if mutability == "" || mutability == "nonpayable" {
- str = fmt.Sprintf("%v(%v) returns(%v)", identity, strings.Join(inputNames, ", "), strings.Join(outputNames, ", "))
- } else {
- str = fmt.Sprintf("%v(%v) %s returns(%v)", identity, strings.Join(inputNames, ", "), mutability, 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/accounts/abi/method_test.go b/accounts/abi/method_test.go
deleted file mode 100644
index 6322173920..0000000000
--- a/accounts/abi/method_test.go
+++ /dev/null
@@ -1,148 +0,0 @@
-// 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) {
- t.Parallel()
- 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
- switch test.method {
- case "fallback":
- got = abi.Fallback.String()
- case "receive":
- got = abi.Receive.String()
- default:
- 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) {
- t.Parallel()
- 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/accounts/abi/pack.go b/accounts/abi/pack.go
deleted file mode 100644
index beef1fa37f..0000000000
--- a/accounts/abi/pack.go
+++ /dev/null
@@ -1,85 +0,0 @@
-// 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/accounts/abi/pack_test.go b/accounts/abi/pack_test.go
deleted file mode 100644
index 00bdae469e..0000000000
--- a/accounts/abi/pack_test.go
+++ /dev/null
@@ -1,216 +0,0 @@
-// 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) {
- t.Parallel()
- for i, test := range packUnpackTests {
- i, test := i, test
- t.Run(strconv.Itoa(i), func(t *testing.T) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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/accounts/abi/packing_test.go b/accounts/abi/packing_test.go
deleted file mode 100644
index eae3b0df20..0000000000
--- a/accounts/abi/packing_test.go
+++ /dev/null
@@ -1,990 +0,0 @@
-// 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/accounts/abi/reflect.go b/accounts/abi/reflect.go
deleted file mode 100644
index 1863e5bb7d..0000000000
--- a/accounts/abi/reflect.go
+++ /dev/null
@@ -1,264 +0,0 @@
-// 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 this code:
-//
-// 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() && (dst.Elem().Type().Kind() == reflect.Ptr || dst.Elem().CanSet()):
- 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, errors.New("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/accounts/abi/reflect_test.go b/accounts/abi/reflect_test.go
deleted file mode 100644
index 6c7ae57087..0000000000
--- a/accounts/abi/reflect_test.go
+++ /dev/null
@@ -1,265 +0,0 @@
-// 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: "OneToOneCorrespondence",
- 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) {
- t.Parallel()
- for _, test := range reflectTests {
- test := test
- t.Run(test.name, func(t *testing.T) {
- t.Parallel()
- 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) {
- t.Parallel()
- // 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/accounts/abi/selector_parser.go b/accounts/abi/selector_parser.go
deleted file mode 100644
index b8ddd7d656..0000000000
--- a/accounts/abi/selector_parser.go
+++ /dev/null
@@ -1,177 +0,0 @@
-// 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 (
- "errors"
- "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 "", "", errors.New("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, "", errors.New("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})
- } 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})
- } 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 construct 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/accounts/abi/selector_parser_test.go b/accounts/abi/selector_parser_test.go
deleted file mode 100644
index 6cb0ae0e70..0000000000
--- a/accounts/abi/selector_parser_test.go
+++ /dev/null
@@ -1,80 +0,0 @@
-// 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) {
- t.Parallel()
- 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/accounts/abi/topics.go b/accounts/abi/topics.go
deleted file mode 100644
index 60c71d88b2..0000000000
--- a/accounts/abi/topics.go
+++ /dev/null
@@ -1,173 +0,0 @@
-// 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 to 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/accounts/abi/topics_test.go b/accounts/abi/topics_test.go
deleted file mode 100644
index b31f58fba3..0000000000
--- a/accounts/abi/topics_test.go
+++ /dev/null
@@ -1,390 +0,0 @@
-// 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) {
- t.Parallel()
- 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 {
- tt := tt
- t.Run(tt.name, func(t *testing.T) {
- t.Parallel()
- 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) {
- t.Parallel()
- tests := setupTopicsTests()
-
- for _, tt := range tests {
- tt := tt
- t.Run(tt.name, func(t *testing.T) {
- t.Parallel()
- 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) {
- t.Parallel()
- tests := setupTopicsTests()
-
- for _, tt := range tests {
- tt := tt
- t.Run(tt.name, func(t *testing.T) {
- t.Parallel()
- 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/accounts/abi/type.go b/accounts/abi/type.go
deleted file mode 100644
index 2eee11787f..0000000000
--- a/accounts/abi/type.go
+++ /dev/null
@@ -1,426 +0,0 @@
-// 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
-)
-
-// 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{}, errors.New("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{}, errors.New("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 {
- if varSize > 32 {
- return Type{}, fmt.Errorf("unsupported arg type: %s", t)
- }
- 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
- 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)
- }
-}
-
-// requiresLengthPrefix 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/accounts/abi/type_test.go b/accounts/abi/type_test.go
deleted file mode 100644
index ae69872ad8..0000000000
--- a/accounts/abi/type_test.go
+++ /dev/null
@@ -1,380 +0,0 @@
-// 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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)
- }
- }
-}
-
-func TestNewFixedBytesOver32(t *testing.T) {
- t.Parallel()
- _, err := NewType("bytes4096", "", nil)
- if err == nil {
- t.Errorf("fixed bytes with size over 32 is not spec'd")
- }
-}
diff --git a/accounts/abi/unpack.go b/accounts/abi/unpack.go
deleted file mode 100644
index 905b5ce629..0000000000
--- a/accounts/abi/unpack.go
+++ /dev/null
@@ -1,329 +0,0 @@
-// 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"
- "errors"
- "fmt"
- "math"
- "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{}, error) {
- ret := new(big.Int).SetBytes(b)
-
- if typ.T == UintTy {
- u64, isu64 := ret.Uint64(), ret.IsUint64()
- switch typ.Size {
- case 8:
- if !isu64 || u64 > math.MaxUint8 {
- return nil, errBadUint8
- }
- return byte(u64), nil
- case 16:
- if !isu64 || u64 > math.MaxUint16 {
- return nil, errBadUint16
- }
- return uint16(u64), nil
- case 32:
- if !isu64 || u64 > math.MaxUint32 {
- return nil, errBadUint32
- }
- return uint32(u64), nil
- case 64:
- if !isu64 {
- return nil, errBadUint64
- }
- return u64, nil
- default:
- // the only case left for unsigned integer is uint256.
- return ret, nil
- }
- }
-
- // 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.
- if ret.Bit(255) == 1 {
- ret.Add(MaxUint256, new(big.Int).Neg(ret))
- ret.Add(ret, common.Big1)
- ret.Neg(ret)
- }
- i64, isi64 := ret.Int64(), ret.IsInt64()
- switch typ.Size {
- case 8:
- if !isi64 || i64 < math.MinInt8 || i64 > math.MaxInt8 {
- return nil, errBadInt8
- }
- return int8(i64), nil
- case 16:
- if !isi64 || i64 < math.MinInt16 || i64 > math.MaxInt16 {
- return nil, errBadInt16
- }
- return int16(i64), nil
- case 32:
- if !isi64 || i64 < math.MinInt32 || i64 > math.MaxInt32 {
- return nil, errBadInt32
- }
- return int32(i64), nil
- case 64:
- if !isi64 {
- return nil, errBadInt64
- }
- return i64, nil
- default:
- // the only case left for integer is int256
-
- return ret, nil
- }
-}
-
-// 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{}, errors.New("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, errors.New("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 into 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
-
- switch t.T {
- case SliceTy:
- // declare our slice
- refSlice = reflect.MakeSlice(t.GetType(), size, size)
- case ArrayTy:
- // declare our array
- refSlice = reflect.New(t.GetType()).Elem()
- default:
- return nil, errors.New("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 err != nil {
- return nil, err
- }
- 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
- }
- 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)
- 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/accounts/abi/unpack_test.go b/accounts/abi/unpack_test.go
deleted file mode 100644
index 29891ec0a4..0000000000
--- a/accounts/abi/unpack_test.go
+++ /dev/null
@@ -1,1119 +0,0 @@
-// 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"
- "github.com/stretchr/testify/require"
-)
-
-// TestUnpack tests the general pack/unpack tests in packing_test.go
-func TestUnpack(t *testing.T) {
- t.Parallel()
- 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 unmarshal an empty string while arguments are expected",
- },
- {
- def: `[{"type":"bytes32","indexed":true},{"type":"uint256","indexed":false}]`,
- enc: "",
- want: false,
- err: "abi: attempting to unmarshal 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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",
- }, {
- &[]interface{}{&bigint, ""},
- &[]interface{}{&expected.Int, expected.String},
- "",
- "Can unpack into a slice without indirection",
- }, {
- &[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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- // 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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) {
- t.Parallel()
- 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)
- }
- }
-}
-
-func TestPackAndUnpackIncompatibleNumber(t *testing.T) {
- t.Parallel()
- var encodeABI Arguments
- uint256Ty, err := NewType("uint256", "", nil)
- if err != nil {
- panic(err)
- }
- encodeABI = Arguments{
- {Type: uint256Ty},
- }
-
- maxU64, ok := new(big.Int).SetString(strconv.FormatUint(math.MaxUint64, 10), 10)
- if !ok {
- panic("bug")
- }
- maxU64Plus1 := new(big.Int).Add(maxU64, big.NewInt(1))
- cases := []struct {
- decodeType string
- inputValue *big.Int
- err error
- expectValue interface{}
- }{
- {
- decodeType: "uint8",
- inputValue: big.NewInt(math.MaxUint8 + 1),
- err: errBadUint8,
- },
- {
- decodeType: "uint8",
- inputValue: big.NewInt(math.MaxUint8),
- err: nil,
- expectValue: uint8(math.MaxUint8),
- },
- {
- decodeType: "uint16",
- inputValue: big.NewInt(math.MaxUint16 + 1),
- err: errBadUint16,
- },
- {
- decodeType: "uint16",
- inputValue: big.NewInt(math.MaxUint16),
- err: nil,
- expectValue: uint16(math.MaxUint16),
- },
- {
- decodeType: "uint32",
- inputValue: big.NewInt(math.MaxUint32 + 1),
- err: errBadUint32,
- },
- {
- decodeType: "uint32",
- inputValue: big.NewInt(math.MaxUint32),
- err: nil,
- expectValue: uint32(math.MaxUint32),
- },
- {
- decodeType: "uint64",
- inputValue: maxU64Plus1,
- err: errBadUint64,
- },
- {
- decodeType: "uint64",
- inputValue: maxU64,
- err: nil,
- expectValue: uint64(math.MaxUint64),
- },
- {
- decodeType: "uint256",
- inputValue: maxU64Plus1,
- err: nil,
- expectValue: maxU64Plus1,
- },
- {
- decodeType: "int8",
- inputValue: big.NewInt(math.MaxInt8 + 1),
- err: errBadInt8,
- },
- {
- decodeType: "int8",
- inputValue: big.NewInt(math.MinInt8 - 1),
- err: errBadInt8,
- },
- {
- decodeType: "int8",
- inputValue: big.NewInt(math.MaxInt8),
- err: nil,
- expectValue: int8(math.MaxInt8),
- },
- {
- decodeType: "int16",
- inputValue: big.NewInt(math.MaxInt16 + 1),
- err: errBadInt16,
- },
- {
- decodeType: "int16",
- inputValue: big.NewInt(math.MinInt16 - 1),
- err: errBadInt16,
- },
- {
- decodeType: "int16",
- inputValue: big.NewInt(math.MaxInt16),
- err: nil,
- expectValue: int16(math.MaxInt16),
- },
- {
- decodeType: "int32",
- inputValue: big.NewInt(math.MaxInt32 + 1),
- err: errBadInt32,
- },
- {
- decodeType: "int32",
- inputValue: big.NewInt(math.MinInt32 - 1),
- err: errBadInt32,
- },
- {
- decodeType: "int32",
- inputValue: big.NewInt(math.MaxInt32),
- err: nil,
- expectValue: int32(math.MaxInt32),
- },
- {
- decodeType: "int64",
- inputValue: new(big.Int).Add(big.NewInt(math.MaxInt64), big.NewInt(1)),
- err: errBadInt64,
- },
- {
- decodeType: "int64",
- inputValue: new(big.Int).Sub(big.NewInt(math.MinInt64), big.NewInt(1)),
- err: errBadInt64,
- },
- {
- decodeType: "int64",
- inputValue: big.NewInt(math.MaxInt64),
- err: nil,
- expectValue: int64(math.MaxInt64),
- },
- }
- for i, testCase := range cases {
- packed, err := encodeABI.Pack(testCase.inputValue)
- if err != nil {
- panic(err)
- }
- ty, err := NewType(testCase.decodeType, "", nil)
- if err != nil {
- panic(err)
- }
- decodeABI := Arguments{
- {Type: ty},
- }
- decoded, err := decodeABI.Unpack(packed)
- if err != testCase.err {
- t.Fatalf("Expected error %v, actual error %v. case %d", testCase.err, err, i)
- }
- if err != nil {
- continue
- }
- if !reflect.DeepEqual(decoded[0], testCase.expectValue) {
- t.Fatalf("Expected value %v, actual value %v", testCase.expectValue, decoded[0])
- }
- }
-}
diff --git a/accounts/abi/utils.go b/accounts/abi/utils.go
deleted file mode 100644
index b1537ca58d..0000000000
--- a/accounts/abi/utils.go
+++ /dev/null
@@ -1,40 +0,0 @@
-// 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" and "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/accounts/accounts.go b/accounts/accounts.go
deleted file mode 100644
index 6c351a9649..0000000000
--- a/accounts/accounts.go
+++ /dev/null
@@ -1,226 +0,0 @@
-// 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 accounts implements high level Ethereum account management.
-package accounts
-
-import (
- "fmt"
- "math/big"
-
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/event"
- "golang.org/x/crypto/sha3"
-)
-
-// Account represents an Ethereum account located at a specific location defined
-// by the optional URL field.
-type Account struct {
- Address common.Address `json:"address"` // Ethereum account address derived from the key
- URL URL `json:"url"` // Optional resource locator within a backend
-}
-
-const (
- MimetypeDataWithValidator = "data/validator"
- MimetypeTypedData = "data/typed"
- MimetypeClique = "application/x-clique-header"
- MimetypeTextPlain = "text/plain"
-)
-
-// Wallet represents a software or hardware wallet that might contain one or more
-// accounts (derived from the same seed).
-type Wallet interface {
- // URL retrieves the canonical path under which this wallet is reachable. It is
- // used by upper layers to define a sorting order over all wallets from multiple
- // backends.
- URL() URL
-
- // Status returns a textual status to aid the user in the current state of the
- // wallet. It also returns an error indicating any failure the wallet might have
- // encountered.
- Status() (string, error)
-
- // Open initializes access to a wallet instance. It is not meant to unlock or
- // decrypt account keys, rather simply to establish a connection to hardware
- // wallets and/or to access derivation seeds.
- //
- // The passphrase parameter may or may not be used by the implementation of a
- // particular wallet instance. The reason there is no passwordless open method
- // is to strive towards a uniform wallet handling, oblivious to the different
- // backend providers.
- //
- // Please note, if you open a wallet, you must close it to release any allocated
- // resources (especially important when working with hardware wallets).
- Open(passphrase string) error
-
- // Close releases any resources held by an open wallet instance.
- Close() error
-
- // Accounts retrieves the list of signing accounts the wallet is currently aware
- // of. For hierarchical deterministic wallets, the list will not be exhaustive,
- // rather only contain the accounts explicitly pinned during account derivation.
- Accounts() []Account
-
- // Contains returns whether an account is part of this particular wallet or not.
- Contains(account Account) bool
-
- // Derive attempts to explicitly derive a hierarchical deterministic account at
- // the specified derivation path. If requested, the derived account will be added
- // to the wallet's tracked account list.
- Derive(path DerivationPath, pin bool) (Account, error)
-
- // SelfDerive sets a base account derivation path from which the wallet attempts
- // to discover non zero accounts and automatically add them to list of tracked
- // accounts.
- //
- // Note, self derivation will increment the last component of the specified path
- // opposed to descending into a child path to allow discovering accounts starting
- // from non zero components.
- //
- // Some hardware wallets switched derivation paths through their evolution, so
- // this method supports providing multiple bases to discover old user accounts
- // too. Only the last base will be used to derive the next empty account.
- //
- // You can disable automatic account discovery by calling SelfDerive with a nil
- // chain state reader.
- SelfDerive(bases []DerivationPath, chain ethereum.ChainStateReader)
-
- // SignData requests the wallet to sign the hash of the given data
- // It looks up the account specified either solely via its address contained within,
- // or optionally with the aid of any location metadata from the embedded URL field.
- //
- // If the wallet requires additional authentication to sign the request (e.g.
- // a password to decrypt the account, or a PIN code to verify the transaction),
- // an AuthNeededError instance will be returned, containing infos for the user
- // about which fields or actions are needed. The user may retry by providing
- // the needed details via SignDataWithPassphrase, or by other means (e.g. unlock
- // the account in a keystore).
- SignData(account Account, mimeType string, data []byte) ([]byte, error)
-
- // SignDataWithPassphrase is identical to SignData, but also takes a password
- // NOTE: there's a chance that an erroneous call might mistake the two strings, and
- // supply password in the mimetype field, or vice versa. Thus, an implementation
- // should never echo the mimetype or return the mimetype in the error-response
- SignDataWithPassphrase(account Account, passphrase, mimeType string, data []byte) ([]byte, error)
-
- // SignText requests the wallet to sign the hash of a given piece of data, prefixed
- // by the Ethereum prefix scheme
- // It looks up the account specified either solely via its address contained within,
- // or optionally with the aid of any location metadata from the embedded URL field.
- //
- // If the wallet requires additional authentication to sign the request (e.g.
- // a password to decrypt the account, or a PIN code to verify the transaction),
- // an AuthNeededError instance will be returned, containing infos for the user
- // about which fields or actions are needed. The user may retry by providing
- // the needed details via SignTextWithPassphrase, or by other means (e.g. unlock
- // the account in a keystore).
- //
- // This method should return the signature in 'canonical' format, with v 0 or 1.
- SignText(account Account, text []byte) ([]byte, error)
-
- // SignTextWithPassphrase is identical to Signtext, but also takes a password
- SignTextWithPassphrase(account Account, passphrase string, hash []byte) ([]byte, error)
-
- // SignTx requests the wallet to sign the given transaction.
- //
- // It looks up the account specified either solely via its address contained within,
- // or optionally with the aid of any location metadata from the embedded URL field.
- //
- // If the wallet requires additional authentication to sign the request (e.g.
- // a password to decrypt the account, or a PIN code to verify the transaction),
- // an AuthNeededError instance will be returned, containing infos for the user
- // about which fields or actions are needed. The user may retry by providing
- // the needed details via SignTxWithPassphrase, or by other means (e.g. unlock
- // the account in a keystore).
- SignTx(account Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error)
-
- // SignTxWithPassphrase is identical to SignTx, but also takes a password
- SignTxWithPassphrase(account Account, passphrase string, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error)
-}
-
-// Backend is a "wallet provider" that may contain a batch of accounts they can
-// sign transactions with and upon request, do so.
-type Backend interface {
- // Wallets retrieves the list of wallets the backend is currently aware of.
- //
- // The returned wallets are not opened by default. For software HD wallets this
- // means that no base seeds are decrypted, and for hardware wallets that no actual
- // connection is established.
- //
- // The resulting wallet list will be sorted alphabetically based on its internal
- // URL assigned by the backend. Since wallets (especially hardware) may come and
- // go, the same wallet might appear at a different positions in the list during
- // subsequent retrievals.
- Wallets() []Wallet
-
- // Subscribe creates an async subscription to receive notifications when the
- // backend detects the arrival or departure of a wallet.
- Subscribe(sink chan<- WalletEvent) event.Subscription
-}
-
-// TextHash is a helper function that calculates a hash for the given message that can be
-// safely used to calculate a signature from.
-//
-// The hash is calculated as
-//
-// keccak256("\x19Ethereum Signed Message:\n"${message length}${message}).
-//
-// This gives context to the signed message and prevents signing of transactions.
-func TextHash(data []byte) []byte {
- hash, _ := TextAndHash(data)
- return hash
-}
-
-// TextAndHash is a helper function that calculates a hash for the given message that can be
-// safely used to calculate a signature from.
-//
-// The hash is calculated as
-//
-// keccak256("\x19Ethereum Signed Message:\n"${message length}${message}).
-//
-// This gives context to the signed message and prevents signing of transactions.
-func TextAndHash(data []byte) ([]byte, string) {
- msg := fmt.Sprintf("\x19Ethereum Signed Message:\n%d%s", len(data), string(data))
- hasher := sha3.NewLegacyKeccak256()
- hasher.Write([]byte(msg))
- return hasher.Sum(nil), msg
-}
-
-// WalletEventType represents the different event types that can be fired by
-// the wallet subscription subsystem.
-type WalletEventType int
-
-const (
- // WalletArrived is fired when a new wallet is detected either via USB or via
- // a filesystem event in the keystore.
- WalletArrived WalletEventType = iota
-
- // WalletOpened is fired when a wallet is successfully opened with the purpose
- // of starting any background processes such as automatic key derivation.
- WalletOpened
-
- // WalletDropped
- WalletDropped
-)
-
-// WalletEvent is an event fired by an account backend when a wallet arrival or
-// departure is detected.
-type WalletEvent struct {
- Wallet Wallet // Wallet instance arrived or departed
- Kind WalletEventType // Event type that happened in the system
-}
diff --git a/accounts/accounts_test.go b/accounts/accounts_test.go
deleted file mode 100644
index 2c4138aa78..0000000000
--- a/accounts/accounts_test.go
+++ /dev/null
@@ -1,33 +0,0 @@
-// 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 accounts
-
-import (
- "bytes"
- "testing"
-
- "github.com/ethereum/go-ethereum/common/hexutil"
-)
-
-func TestTextHash(t *testing.T) {
- t.Parallel()
- hash := TextHash([]byte("Hello Joe"))
- want := hexutil.MustDecode("0xa080337ae51c4e064c189e113edd0ba391df9206e2f49db658bb32cf2911730b")
- if !bytes.Equal(hash, want) {
- t.Fatalf("wrong hash: %x", hash)
- }
-}
diff --git a/accounts/errors.go b/accounts/errors.go
deleted file mode 100644
index 03cb569eba..0000000000
--- a/accounts/errors.go
+++ /dev/null
@@ -1,67 +0,0 @@
-// 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 accounts
-
-import (
- "errors"
- "fmt"
-)
-
-// ErrUnknownAccount is returned for any requested operation for which no backend
-// provides the specified account.
-var ErrUnknownAccount = errors.New("unknown account")
-
-// ErrUnknownWallet is returned for any requested operation for which no backend
-// provides the specified wallet.
-var ErrUnknownWallet = errors.New("unknown wallet")
-
-// ErrNotSupported is returned when an operation is requested from an account
-// backend that it does not support.
-var ErrNotSupported = errors.New("not supported")
-
-// ErrInvalidPassphrase is returned when a decryption operation receives a bad
-// passphrase.
-var ErrInvalidPassphrase = errors.New("invalid password")
-
-// ErrWalletAlreadyOpen is returned if a wallet is attempted to be opened the
-// second time.
-var ErrWalletAlreadyOpen = errors.New("wallet already open")
-
-// ErrWalletClosed is returned if a wallet is offline.
-var ErrWalletClosed = errors.New("wallet closed")
-
-// AuthNeededError is returned by backends for signing requests where the user
-// is required to provide further authentication before signing can succeed.
-//
-// This usually means either that a password needs to be supplied, or perhaps a
-// one time PIN code displayed by some hardware device.
-type AuthNeededError struct {
- Needed string // Extra authentication the user needs to provide
-}
-
-// NewAuthNeededError creates a new authentication error with the extra details
-// about the needed fields set.
-func NewAuthNeededError(needed string) error {
- return &AuthNeededError{
- Needed: needed,
- }
-}
-
-// Error implements the standard error interface.
-func (err *AuthNeededError) Error() string {
- return fmt.Sprintf("authentication needed: %s", err.Needed)
-}
diff --git a/accounts/external/backend.go b/accounts/external/backend.go
deleted file mode 100644
index 6f1581f9b8..0000000000
--- a/accounts/external/backend.go
+++ /dev/null
@@ -1,270 +0,0 @@
-// 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 external
-
-import (
- "errors"
- "fmt"
- "math/big"
- "sync"
-
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/accounts"
- "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/event"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rpc"
- "github.com/ethereum/go-ethereum/signer/core/apitypes"
-)
-
-type ExternalBackend struct {
- signers []accounts.Wallet
-}
-
-func (eb *ExternalBackend) Wallets() []accounts.Wallet {
- return eb.signers
-}
-
-func NewExternalBackend(endpoint string) (*ExternalBackend, error) {
- signer, err := NewExternalSigner(endpoint)
- if err != nil {
- return nil, err
- }
- return &ExternalBackend{
- signers: []accounts.Wallet{signer},
- }, nil
-}
-
-func (eb *ExternalBackend) Subscribe(sink chan<- accounts.WalletEvent) event.Subscription {
- return event.NewSubscription(func(quit <-chan struct{}) error {
- <-quit
- return nil
- })
-}
-
-// ExternalSigner provides an API to interact with an external signer (clef)
-// It proxies request to the external signer while forwarding relevant
-// request headers
-type ExternalSigner struct {
- client *rpc.Client
- endpoint string
- status string
- cacheMu sync.RWMutex
- cache []accounts.Account
-}
-
-func NewExternalSigner(endpoint string) (*ExternalSigner, error) {
- client, err := rpc.Dial(endpoint)
- if err != nil {
- return nil, err
- }
- extsigner := &ExternalSigner{
- client: client,
- endpoint: endpoint,
- }
- // Check if reachable
- version, err := extsigner.pingVersion()
- if err != nil {
- return nil, err
- }
- extsigner.status = fmt.Sprintf("ok [version=%v]", version)
- return extsigner, nil
-}
-
-func (api *ExternalSigner) URL() accounts.URL {
- return accounts.URL{
- Scheme: "extapi",
- Path: api.endpoint,
- }
-}
-
-func (api *ExternalSigner) Status() (string, error) {
- return api.status, nil
-}
-
-func (api *ExternalSigner) Open(passphrase string) error {
- return errors.New("operation not supported on external signers")
-}
-
-func (api *ExternalSigner) Close() error {
- return errors.New("operation not supported on external signers")
-}
-
-func (api *ExternalSigner) Accounts() []accounts.Account {
- var accnts []accounts.Account
- res, err := api.listAccounts()
- if err != nil {
- log.Error("account listing failed", "error", err)
- return accnts
- }
- for _, addr := range res {
- accnts = append(accnts, accounts.Account{
- URL: accounts.URL{
- Scheme: "extapi",
- Path: api.endpoint,
- },
- Address: addr,
- })
- }
- api.cacheMu.Lock()
- api.cache = accnts
- api.cacheMu.Unlock()
- return accnts
-}
-
-func (api *ExternalSigner) Contains(account accounts.Account) bool {
- api.cacheMu.RLock()
- defer api.cacheMu.RUnlock()
- if api.cache == nil {
- // If we haven't already fetched the accounts, it's time to do so now
- api.cacheMu.RUnlock()
- api.Accounts()
- api.cacheMu.RLock()
- }
- for _, a := range api.cache {
- if a.Address == account.Address && (account.URL == (accounts.URL{}) || account.URL == api.URL()) {
- return true
- }
- }
- return false
-}
-
-func (api *ExternalSigner) Derive(path accounts.DerivationPath, pin bool) (accounts.Account, error) {
- return accounts.Account{}, errors.New("operation not supported on external signers")
-}
-
-func (api *ExternalSigner) SelfDerive(bases []accounts.DerivationPath, chain ethereum.ChainStateReader) {
- log.Error("operation SelfDerive not supported on external signers")
-}
-
-// SignData signs keccak256(data). The mimetype parameter describes the type of data being signed
-func (api *ExternalSigner) SignData(account accounts.Account, mimeType string, data []byte) ([]byte, error) {
- var res hexutil.Bytes
- var signAddress = common.NewMixedcaseAddress(account.Address)
- if err := api.client.Call(&res, "account_signData",
- mimeType,
- &signAddress, // Need to use the pointer here, because of how MarshalJSON is defined
- hexutil.Encode(data)); err != nil {
- return nil, err
- }
- // If V is on 27/28-form, convert to 0/1 for Clique
- if mimeType == accounts.MimetypeClique && (res[64] == 27 || res[64] == 28) {
- res[64] -= 27 // Transform V from 27/28 to 0/1 for Clique use
- }
- return res, nil
-}
-
-func (api *ExternalSigner) SignText(account accounts.Account, text []byte) ([]byte, error) {
- var signature hexutil.Bytes
- var signAddress = common.NewMixedcaseAddress(account.Address)
- if err := api.client.Call(&signature, "account_signData",
- accounts.MimetypeTextPlain,
- &signAddress, // Need to use the pointer here, because of how MarshalJSON is defined
- hexutil.Encode(text)); err != nil {
- return nil, err
- }
- if signature[64] == 27 || signature[64] == 28 {
- // If clef is used as a backend, it may already have transformed
- // the signature to ethereum-type signature.
- signature[64] -= 27 // Transform V from Ethereum-legacy to 0/1
- }
- return signature, nil
-}
-
-// signTransactionResult represents the signinig result returned by clef.
-type signTransactionResult struct {
- Raw hexutil.Bytes `json:"raw"`
- Tx *types.Transaction `json:"tx"`
-}
-
-// SignTx sends the transaction to the external signer.
-// If chainID is nil, or tx.ChainID is zero, the chain ID will be assigned
-// by the external signer. For non-legacy transactions, the chain ID of the
-// transaction overrides the chainID parameter.
-func (api *ExternalSigner) SignTx(account accounts.Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
- data := hexutil.Bytes(tx.Data())
- var to *common.MixedcaseAddress
- if tx.To() != nil {
- t := common.NewMixedcaseAddress(*tx.To())
- to = &t
- }
- args := &apitypes.SendTxArgs{
- Data: &data,
- Nonce: hexutil.Uint64(tx.Nonce()),
- Value: hexutil.Big(*tx.Value()),
- Gas: hexutil.Uint64(tx.Gas()),
- To: to,
- From: common.NewMixedcaseAddress(account.Address),
- }
- switch tx.Type() {
- case types.LegacyTxType, types.AccessListTxType:
- args.GasPrice = (*hexutil.Big)(tx.GasPrice())
- case types.DynamicFeeTxType:
- args.MaxFeePerGas = (*hexutil.Big)(tx.GasFeeCap())
- args.MaxPriorityFeePerGas = (*hexutil.Big)(tx.GasTipCap())
- default:
- return nil, fmt.Errorf("unsupported tx type %d", tx.Type())
- }
- // We should request the default chain id that we're operating with
- // (the chain we're executing on)
- if chainID != nil && chainID.Sign() != 0 {
- args.ChainID = (*hexutil.Big)(chainID)
- }
- if tx.Type() != types.LegacyTxType {
- // However, if the user asked for a particular chain id, then we should
- // use that instead.
- if tx.ChainId().Sign() != 0 {
- args.ChainID = (*hexutil.Big)(tx.ChainId())
- }
- accessList := tx.AccessList()
- args.AccessList = &accessList
- }
- var res signTransactionResult
- if err := api.client.Call(&res, "account_signTransaction", args); err != nil {
- return nil, err
- }
- return res.Tx, nil
-}
-
-func (api *ExternalSigner) SignTextWithPassphrase(account accounts.Account, passphrase string, text []byte) ([]byte, error) {
- return []byte{}, errors.New("password-operations not supported on external signers")
-}
-
-func (api *ExternalSigner) SignTxWithPassphrase(account accounts.Account, passphrase string, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
- return nil, errors.New("password-operations not supported on external signers")
-}
-func (api *ExternalSigner) SignDataWithPassphrase(account accounts.Account, passphrase, mimeType string, data []byte) ([]byte, error) {
- return nil, errors.New("password-operations not supported on external signers")
-}
-
-func (api *ExternalSigner) listAccounts() ([]common.Address, error) {
- var res []common.Address
- if err := api.client.Call(&res, "account_list"); err != nil {
- return nil, err
- }
- return res, nil
-}
-
-func (api *ExternalSigner) pingVersion() (string, error) {
- var v string
- if err := api.client.Call(&v, "account_version"); err != nil {
- return "", err
- }
- return v, nil
-}
diff --git a/accounts/hd.go b/accounts/hd.go
deleted file mode 100644
index daca75ebbc..0000000000
--- a/accounts/hd.go
+++ /dev/null
@@ -1,180 +0,0 @@
-// 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 accounts
-
-import (
- "encoding/json"
- "errors"
- "fmt"
- "math"
- "math/big"
- "strings"
-)
-
-// DefaultRootDerivationPath is the root path to which custom derivation endpoints
-// are appended. As such, the first account will be at m/44'/60'/0'/0, the second
-// at m/44'/60'/0'/1, etc.
-var DefaultRootDerivationPath = DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}
-
-// DefaultBaseDerivationPath is the base path from which custom derivation endpoints
-// are incremented. As such, the first account will be at m/44'/60'/0'/0/0, the second
-// at m/44'/60'/0'/0/1, etc.
-var DefaultBaseDerivationPath = DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0}
-
-// LegacyLedgerBaseDerivationPath is the legacy base path from which custom derivation
-// endpoints are incremented. As such, the first account will be at m/44'/60'/0'/0, the
-// second at m/44'/60'/0'/1, etc.
-var LegacyLedgerBaseDerivationPath = DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}
-
-// DerivationPath represents the computer friendly version of a hierarchical
-// deterministic wallet account derivation path.
-//
-// The BIP-32 spec https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki
-// defines derivation paths to be of the form:
-//
-// m / purpose' / coin_type' / account' / change / address_index
-//
-// The BIP-44 spec https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki
-// defines that the `purpose` be 44' (or 0x8000002C) for crypto currencies, and
-// SLIP-44 https://github.com/satoshilabs/slips/blob/master/slip-0044.md assigns
-// the `coin_type` 60' (or 0x8000003C) to Ethereum.
-//
-// The root path for Ethereum is m/44'/60'/0'/0 according to the specification
-// from https://github.com/ethereum/EIPs/issues/84, albeit it's not set in stone
-// yet whether accounts should increment the last component or the children of
-// that. We will go with the simpler approach of incrementing the last component.
-type DerivationPath []uint32
-
-// ParseDerivationPath converts a user specified derivation path string to the
-// internal binary representation.
-//
-// Full derivation paths need to start with the `m/` prefix, relative derivation
-// paths (which will get appended to the default root path) must not have prefixes
-// in front of the first element. Whitespace is ignored.
-func ParseDerivationPath(path string) (DerivationPath, error) {
- var result DerivationPath
-
- // Handle absolute or relative paths
- components := strings.Split(path, "/")
- switch {
- case len(components) == 0:
- return nil, errors.New("empty derivation path")
-
- case strings.TrimSpace(components[0]) == "":
- return nil, errors.New("ambiguous path: use 'm/' prefix for absolute paths, or no leading '/' for relative ones")
-
- case strings.TrimSpace(components[0]) == "m":
- components = components[1:]
-
- default:
- result = append(result, DefaultRootDerivationPath...)
- }
- // All remaining components are relative, append one by one
- if len(components) == 0 {
- return nil, errors.New("empty derivation path") // Empty relative paths
- }
- for _, component := range components {
- // Ignore any user added whitespace
- component = strings.TrimSpace(component)
- var value uint32
-
- // Handle hardened paths
- if strings.HasSuffix(component, "'") {
- value = 0x80000000
- component = strings.TrimSpace(strings.TrimSuffix(component, "'"))
- }
- // Handle the non hardened component
- bigval, ok := new(big.Int).SetString(component, 0)
- if !ok {
- return nil, fmt.Errorf("invalid component: %s", component)
- }
- max := math.MaxUint32 - value
- if bigval.Sign() < 0 || bigval.Cmp(big.NewInt(int64(max))) > 0 {
- if value == 0 {
- return nil, fmt.Errorf("component %v out of allowed range [0, %d]", bigval, max)
- }
- return nil, fmt.Errorf("component %v out of allowed hardened range [0, %d]", bigval, max)
- }
- value += uint32(bigval.Uint64())
-
- // Append and repeat
- result = append(result, value)
- }
- return result, nil
-}
-
-// String implements the stringer interface, converting a binary derivation path
-// to its canonical representation.
-func (path DerivationPath) String() string {
- result := "m"
- for _, component := range path {
- var hardened bool
- if component >= 0x80000000 {
- component -= 0x80000000
- hardened = true
- }
- result = fmt.Sprintf("%s/%d", result, component)
- if hardened {
- result += "'"
- }
- }
- return result
-}
-
-// MarshalJSON turns a derivation path into its json-serialized string
-func (path DerivationPath) MarshalJSON() ([]byte, error) {
- return json.Marshal(path.String())
-}
-
-// UnmarshalJSON a json-serialized string back into a derivation path
-func (path *DerivationPath) UnmarshalJSON(b []byte) error {
- var dp string
- var err error
- if err = json.Unmarshal(b, &dp); err != nil {
- return err
- }
- *path, err = ParseDerivationPath(dp)
- return err
-}
-
-// DefaultIterator creates a BIP-32 path iterator, which progresses by increasing the last component:
-// i.e. m/44'/60'/0'/0/0, m/44'/60'/0'/0/1, m/44'/60'/0'/0/2, ... m/44'/60'/0'/0/N.
-func DefaultIterator(base DerivationPath) func() DerivationPath {
- path := make(DerivationPath, len(base))
- copy(path[:], base[:])
- // Set it back by one, so the first call gives the first result
- path[len(path)-1]--
- return func() DerivationPath {
- path[len(path)-1]++
- return path
- }
-}
-
-// LedgerLiveIterator creates a bip44 path iterator for Ledger Live.
-// Ledger Live increments the third component rather than the fifth component
-// i.e. m/44'/60'/0'/0/0, m/44'/60'/1'/0/0, m/44'/60'/2'/0/0, ... m/44'/60'/N'/0/0.
-func LedgerLiveIterator(base DerivationPath) func() DerivationPath {
- path := make(DerivationPath, len(base))
- copy(path[:], base[:])
- // Set it back by one, so the first call gives the first result
- path[2]--
- return func() DerivationPath {
- // ledgerLivePathIterator iterates on the third component
- path[2]++
- return path
- }
-}
diff --git a/accounts/hd_test.go b/accounts/hd_test.go
deleted file mode 100644
index 118ec5187b..0000000000
--- a/accounts/hd_test.go
+++ /dev/null
@@ -1,120 +0,0 @@
-// 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 accounts
-
-import (
- "fmt"
- "reflect"
- "testing"
-)
-
-// Tests that HD derivation paths can be correctly parsed into our internal binary
-// representation.
-func TestHDPathParsing(t *testing.T) {
- t.Parallel()
- tests := []struct {
- input string
- output DerivationPath
- }{
- // Plain absolute derivation paths
- {"m/44'/60'/0'/0", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}},
- {"m/44'/60'/0'/128", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 128}},
- {"m/44'/60'/0'/0'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0x80000000 + 0}},
- {"m/44'/60'/0'/128'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0x80000000 + 128}},
- {"m/2147483692/2147483708/2147483648/0", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}},
- {"m/2147483692/2147483708/2147483648/2147483648", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0x80000000 + 0}},
-
- // Plain relative derivation paths
- {"0", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0}},
- {"128", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 128}},
- {"0'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0x80000000 + 0}},
- {"128'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0x80000000 + 128}},
- {"2147483648", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0x80000000 + 0}},
-
- // Hexadecimal absolute derivation paths
- {"m/0x2C'/0x3c'/0x00'/0x00", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}},
- {"m/0x2C'/0x3c'/0x00'/0x80", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 128}},
- {"m/0x2C'/0x3c'/0x00'/0x00'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0x80000000 + 0}},
- {"m/0x2C'/0x3c'/0x00'/0x80'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0x80000000 + 128}},
- {"m/0x8000002C/0x8000003c/0x80000000/0x00", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}},
- {"m/0x8000002C/0x8000003c/0x80000000/0x80000000", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0x80000000 + 0}},
-
- // Hexadecimal relative derivation paths
- {"0x00", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0}},
- {"0x80", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 128}},
- {"0x00'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0x80000000 + 0}},
- {"0x80'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0x80000000 + 128}},
- {"0x80000000", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0x80000000 + 0}},
-
- // Weird inputs just to ensure they work
- {" m / 44 '\n/\n 60 \n\n\t' /\n0 ' /\t\t 0", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}},
-
- // Invalid derivation paths
- {"", nil}, // Empty relative derivation path
- {"m", nil}, // Empty absolute derivation path
- {"m/", nil}, // Missing last derivation component
- {"/44'/60'/0'/0", nil}, // Absolute path without m prefix, might be user error
- {"m/2147483648'", nil}, // Overflows 32 bit integer
- {"m/-1'", nil}, // Cannot contain negative number
- }
- for i, tt := range tests {
- if path, err := ParseDerivationPath(tt.input); !reflect.DeepEqual(path, tt.output) {
- t.Errorf("test %d: parse mismatch: have %v (%v), want %v", i, path, err, tt.output)
- } else if path == nil && err == nil {
- t.Errorf("test %d: nil path and error: %v", i, err)
- }
- }
-}
-
-func testDerive(t *testing.T, next func() DerivationPath, expected []string) {
- t.Helper()
- for i, want := range expected {
- if have := next(); fmt.Sprintf("%v", have) != want {
- t.Errorf("step %d, have %v, want %v", i, have, want)
- }
- }
-}
-
-func TestHdPathIteration(t *testing.T) {
- t.Parallel()
- testDerive(t, DefaultIterator(DefaultBaseDerivationPath),
- []string{
- "m/44'/60'/0'/0/0", "m/44'/60'/0'/0/1",
- "m/44'/60'/0'/0/2", "m/44'/60'/0'/0/3",
- "m/44'/60'/0'/0/4", "m/44'/60'/0'/0/5",
- "m/44'/60'/0'/0/6", "m/44'/60'/0'/0/7",
- "m/44'/60'/0'/0/8", "m/44'/60'/0'/0/9",
- })
-
- testDerive(t, DefaultIterator(LegacyLedgerBaseDerivationPath),
- []string{
- "m/44'/60'/0'/0", "m/44'/60'/0'/1",
- "m/44'/60'/0'/2", "m/44'/60'/0'/3",
- "m/44'/60'/0'/4", "m/44'/60'/0'/5",
- "m/44'/60'/0'/6", "m/44'/60'/0'/7",
- "m/44'/60'/0'/8", "m/44'/60'/0'/9",
- })
-
- testDerive(t, LedgerLiveIterator(DefaultBaseDerivationPath),
- []string{
- "m/44'/60'/0'/0/0", "m/44'/60'/1'/0/0",
- "m/44'/60'/2'/0/0", "m/44'/60'/3'/0/0",
- "m/44'/60'/4'/0/0", "m/44'/60'/5'/0/0",
- "m/44'/60'/6'/0/0", "m/44'/60'/7'/0/0",
- "m/44'/60'/8'/0/0", "m/44'/60'/9'/0/0",
- })
-}
diff --git a/accounts/keystore/account_cache.go b/accounts/keystore/account_cache.go
deleted file mode 100644
index 4ed1439514..0000000000
--- a/accounts/keystore/account_cache.go
+++ /dev/null
@@ -1,308 +0,0 @@
-// 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 keystore
-
-import (
- "bufio"
- "encoding/json"
- "fmt"
- "os"
- "path/filepath"
- "sort"
- "strings"
- "sync"
- "time"
-
- mapset "github.com/deckarep/golang-set/v2"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/log"
- "golang.org/x/exp/slices"
-)
-
-// Minimum amount of time between cache reloads. This limit applies if the platform does
-// not support change notifications. It also applies if the keystore directory does not
-// exist yet, the code will attempt to create a watcher at most this often.
-const minReloadInterval = 2 * time.Second
-
-// byURL defines the sorting order for accounts.
-func byURL(a, b accounts.Account) int {
- return a.URL.Cmp(b.URL)
-}
-
-// AmbiguousAddrError is returned when attempting to unlock
-// an address for which more than one file exists.
-type AmbiguousAddrError struct {
- Addr common.Address
- Matches []accounts.Account
-}
-
-func (err *AmbiguousAddrError) Error() string {
- files := ""
- for i, a := range err.Matches {
- files += a.URL.Path
- if i < len(err.Matches)-1 {
- files += ", "
- }
- }
- return fmt.Sprintf("multiple keys match address (%s)", files)
-}
-
-// accountCache is a live index of all accounts in the keystore.
-type accountCache struct {
- keydir string
- watcher *watcher
- mu sync.Mutex
- all []accounts.Account
- byAddr map[common.Address][]accounts.Account
- throttle *time.Timer
- notify chan struct{}
- fileC fileCache
-}
-
-func newAccountCache(keydir string) (*accountCache, chan struct{}) {
- ac := &accountCache{
- keydir: keydir,
- byAddr: make(map[common.Address][]accounts.Account),
- notify: make(chan struct{}, 1),
- fileC: fileCache{all: mapset.NewThreadUnsafeSet[string]()},
- }
- ac.watcher = newWatcher(ac)
- return ac, ac.notify
-}
-
-func (ac *accountCache) accounts() []accounts.Account {
- ac.maybeReload()
- ac.mu.Lock()
- defer ac.mu.Unlock()
- cpy := make([]accounts.Account, len(ac.all))
- copy(cpy, ac.all)
- return cpy
-}
-
-func (ac *accountCache) hasAddress(addr common.Address) bool {
- ac.maybeReload()
- ac.mu.Lock()
- defer ac.mu.Unlock()
- return len(ac.byAddr[addr]) > 0
-}
-
-func (ac *accountCache) add(newAccount accounts.Account) {
- ac.mu.Lock()
- defer ac.mu.Unlock()
-
- i := sort.Search(len(ac.all), func(i int) bool { return ac.all[i].URL.Cmp(newAccount.URL) >= 0 })
- if i < len(ac.all) && ac.all[i] == newAccount {
- return
- }
- // newAccount is not in the cache.
- ac.all = append(ac.all, accounts.Account{})
- copy(ac.all[i+1:], ac.all[i:])
- ac.all[i] = newAccount
- ac.byAddr[newAccount.Address] = append(ac.byAddr[newAccount.Address], newAccount)
-}
-
-// note: removed needs to be unique here (i.e. both File and Address must be set).
-func (ac *accountCache) delete(removed accounts.Account) {
- ac.mu.Lock()
- defer ac.mu.Unlock()
-
- ac.all = removeAccount(ac.all, removed)
- if ba := removeAccount(ac.byAddr[removed.Address], removed); len(ba) == 0 {
- delete(ac.byAddr, removed.Address)
- } else {
- ac.byAddr[removed.Address] = ba
- }
-}
-
-// deleteByFile removes an account referenced by the given path.
-func (ac *accountCache) deleteByFile(path string) {
- ac.mu.Lock()
- defer ac.mu.Unlock()
- i := sort.Search(len(ac.all), func(i int) bool { return ac.all[i].URL.Path >= path })
-
- if i < len(ac.all) && ac.all[i].URL.Path == path {
- removed := ac.all[i]
- ac.all = append(ac.all[:i], ac.all[i+1:]...)
- if ba := removeAccount(ac.byAddr[removed.Address], removed); len(ba) == 0 {
- delete(ac.byAddr, removed.Address)
- } else {
- ac.byAddr[removed.Address] = ba
- }
- }
-}
-
-// watcherStarted returns true if the watcher loop started running (even if it
-// has since also ended).
-func (ac *accountCache) watcherStarted() bool {
- ac.mu.Lock()
- defer ac.mu.Unlock()
- return ac.watcher.running || ac.watcher.runEnded
-}
-
-func removeAccount(slice []accounts.Account, elem accounts.Account) []accounts.Account {
- for i := range slice {
- if slice[i] == elem {
- return append(slice[:i], slice[i+1:]...)
- }
- }
- return slice
-}
-
-// find returns the cached account for address if there is a unique match.
-// The exact matching rules are explained by the documentation of accounts.Account.
-// Callers must hold ac.mu.
-func (ac *accountCache) find(a accounts.Account) (accounts.Account, error) {
- // Limit search to address candidates if possible.
- matches := ac.all
- if (a.Address != common.Address{}) {
- matches = ac.byAddr[a.Address]
- }
- if a.URL.Path != "" {
- // If only the basename is specified, complete the path.
- if !strings.ContainsRune(a.URL.Path, filepath.Separator) {
- a.URL.Path = filepath.Join(ac.keydir, a.URL.Path)
- }
- for i := range matches {
- if matches[i].URL == a.URL {
- return matches[i], nil
- }
- }
- if (a.Address == common.Address{}) {
- return accounts.Account{}, ErrNoMatch
- }
- }
- switch len(matches) {
- case 1:
- return matches[0], nil
- case 0:
- return accounts.Account{}, ErrNoMatch
- default:
- err := &AmbiguousAddrError{Addr: a.Address, Matches: make([]accounts.Account, len(matches))}
- copy(err.Matches, matches)
- slices.SortFunc(err.Matches, byURL)
- return accounts.Account{}, err
- }
-}
-
-func (ac *accountCache) maybeReload() {
- ac.mu.Lock()
-
- if ac.watcher.running {
- ac.mu.Unlock()
- return // A watcher is running and will keep the cache up-to-date.
- }
- if ac.throttle == nil {
- ac.throttle = time.NewTimer(0)
- } else {
- select {
- case <-ac.throttle.C:
- default:
- ac.mu.Unlock()
- return // The cache was reloaded recently.
- }
- }
- // No watcher running, start it.
- ac.watcher.start()
- ac.throttle.Reset(minReloadInterval)
- ac.mu.Unlock()
- ac.scanAccounts()
-}
-
-func (ac *accountCache) close() {
- ac.mu.Lock()
- ac.watcher.close()
- if ac.throttle != nil {
- ac.throttle.Stop()
- }
- if ac.notify != nil {
- close(ac.notify)
- ac.notify = nil
- }
- ac.mu.Unlock()
-}
-
-// scanAccounts checks if any changes have occurred on the filesystem, and
-// updates the account cache accordingly
-func (ac *accountCache) scanAccounts() error {
- // Scan the entire folder metadata for file changes
- creates, deletes, updates, err := ac.fileC.scan(ac.keydir)
- if err != nil {
- log.Debug("Failed to reload keystore contents", "err", err)
- return err
- }
- if creates.Cardinality() == 0 && deletes.Cardinality() == 0 && updates.Cardinality() == 0 {
- return nil
- }
- // Create a helper method to scan the contents of the key files
- var (
- buf = new(bufio.Reader)
- key struct {
- Address string `json:"address"`
- }
- )
- readAccount := func(path string) *accounts.Account {
- fd, err := os.Open(path)
- if err != nil {
- log.Trace("Failed to open keystore file", "path", path, "err", err)
- return nil
- }
- defer fd.Close()
- buf.Reset(fd)
- // Parse the address.
- key.Address = ""
- err = json.NewDecoder(buf).Decode(&key)
- addr := common.HexToAddress(key.Address)
- switch {
- case err != nil:
- log.Debug("Failed to decode keystore key", "path", path, "err", err)
- case addr == common.Address{}:
- log.Debug("Failed to decode keystore key", "path", path, "err", "missing or zero address")
- default:
- return &accounts.Account{
- Address: addr,
- URL: accounts.URL{Scheme: KeyStoreScheme, Path: path},
- }
- }
- return nil
- }
- // Process all the file diffs
- start := time.Now()
-
- for _, path := range creates.ToSlice() {
- if a := readAccount(path); a != nil {
- ac.add(*a)
- }
- }
- for _, path := range deletes.ToSlice() {
- ac.deleteByFile(path)
- }
- for _, path := range updates.ToSlice() {
- ac.deleteByFile(path)
- if a := readAccount(path); a != nil {
- ac.add(*a)
- }
- }
- end := time.Now()
-
- select {
- case ac.notify <- struct{}{}:
- default:
- }
- log.Trace("Handled keystore changes", "time", end.Sub(start))
- return nil
-}
diff --git a/accounts/keystore/account_cache_test.go b/accounts/keystore/account_cache_test.go
deleted file mode 100644
index 48a238048f..0000000000
--- a/accounts/keystore/account_cache_test.go
+++ /dev/null
@@ -1,409 +0,0 @@
-// 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 keystore
-
-import (
- "errors"
- "fmt"
- "math/rand"
- "os"
- "path/filepath"
- "reflect"
- "testing"
- "time"
-
- "github.com/cespare/cp"
- "github.com/davecgh/go-spew/spew"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "golang.org/x/exp/slices"
-)
-
-var (
- cachetestDir, _ = filepath.Abs(filepath.Join("testdata", "keystore"))
- cachetestAccounts = []accounts.Account{
- {
- Address: common.HexToAddress("7ef5a6135f1fd6a02593eedc869c6d41d934aef8"),
- URL: accounts.URL{Scheme: KeyStoreScheme, Path: filepath.Join(cachetestDir, "UTC--2016-03-22T12-57-55.920751759Z--7ef5a6135f1fd6a02593eedc869c6d41d934aef8")},
- },
- {
- Address: common.HexToAddress("f466859ead1932d743d622cb74fc058882e8648a"),
- URL: accounts.URL{Scheme: KeyStoreScheme, Path: filepath.Join(cachetestDir, "aaa")},
- },
- {
- Address: common.HexToAddress("289d485d9771714cce91d3393d764e1311907acc"),
- URL: accounts.URL{Scheme: KeyStoreScheme, Path: filepath.Join(cachetestDir, "zzz")},
- },
- }
-)
-
-// waitWatcherStarts waits up to 1s for the keystore watcher to start.
-func waitWatcherStart(ks *KeyStore) bool {
- // On systems where file watch is not supported, just return "ok".
- if !ks.cache.watcher.enabled() {
- return true
- }
- // The watcher should start, and then exit.
- for t0 := time.Now(); time.Since(t0) < 1*time.Second; time.Sleep(100 * time.Millisecond) {
- if ks.cache.watcherStarted() {
- return true
- }
- }
- return false
-}
-
-func waitForAccounts(wantAccounts []accounts.Account, ks *KeyStore) error {
- var list []accounts.Account
- for t0 := time.Now(); time.Since(t0) < 5*time.Second; time.Sleep(100 * time.Millisecond) {
- list = ks.Accounts()
- if reflect.DeepEqual(list, wantAccounts) {
- // ks should have also received change notifications
- select {
- case <-ks.changes:
- default:
- return errors.New("wasn't notified of new accounts")
- }
- return nil
- }
- }
- return fmt.Errorf("\ngot %v\nwant %v", list, wantAccounts)
-}
-
-func TestWatchNewFile(t *testing.T) {
- t.Parallel()
-
- dir, ks := tmpKeyStore(t, false)
-
- // Ensure the watcher is started before adding any files.
- ks.Accounts()
- if !waitWatcherStart(ks) {
- t.Fatal("keystore watcher didn't start in time")
- }
- // Move in the files.
- wantAccounts := make([]accounts.Account, len(cachetestAccounts))
- for i := range cachetestAccounts {
- wantAccounts[i] = accounts.Account{
- Address: cachetestAccounts[i].Address,
- URL: accounts.URL{Scheme: KeyStoreScheme, Path: filepath.Join(dir, filepath.Base(cachetestAccounts[i].URL.Path))},
- }
- if err := cp.CopyFile(wantAccounts[i].URL.Path, cachetestAccounts[i].URL.Path); err != nil {
- t.Fatal(err)
- }
- }
-
- // ks should see the accounts.
- if err := waitForAccounts(wantAccounts, ks); err != nil {
- t.Error(err)
- }
-}
-
-func TestWatchNoDir(t *testing.T) {
- t.Parallel()
- // Create ks but not the directory that it watches.
- dir := filepath.Join(os.TempDir(), fmt.Sprintf("eth-keystore-watchnodir-test-%d-%d", os.Getpid(), rand.Int()))
- ks := NewKeyStore(dir, LightScryptN, LightScryptP)
- list := ks.Accounts()
- if len(list) > 0 {
- t.Error("initial account list not empty:", list)
- }
- // The watcher should start, and then exit.
- if !waitWatcherStart(ks) {
- t.Fatal("keystore watcher didn't start in time")
- }
- // Create the directory and copy a key file into it.
- os.MkdirAll(dir, 0700)
- defer os.RemoveAll(dir)
- file := filepath.Join(dir, "aaa")
- if err := cp.CopyFile(file, cachetestAccounts[0].URL.Path); err != nil {
- t.Fatal(err)
- }
-
- // ks should see the account.
- wantAccounts := []accounts.Account{cachetestAccounts[0]}
- wantAccounts[0].URL = accounts.URL{Scheme: KeyStoreScheme, Path: file}
- for d := 200 * time.Millisecond; d < 8*time.Second; d *= 2 {
- list = ks.Accounts()
- if reflect.DeepEqual(list, wantAccounts) {
- // ks should have also received change notifications
- select {
- case <-ks.changes:
- default:
- t.Fatalf("wasn't notified of new accounts")
- }
- return
- }
- time.Sleep(d)
- }
- t.Errorf("\ngot %v\nwant %v", list, wantAccounts)
-}
-
-func TestCacheInitialReload(t *testing.T) {
- t.Parallel()
- cache, _ := newAccountCache(cachetestDir)
- accounts := cache.accounts()
- if !reflect.DeepEqual(accounts, cachetestAccounts) {
- t.Fatalf("got initial accounts: %swant %s", spew.Sdump(accounts), spew.Sdump(cachetestAccounts))
- }
-}
-
-func TestCacheAddDeleteOrder(t *testing.T) {
- t.Parallel()
- cache, _ := newAccountCache("testdata/no-such-dir")
- cache.watcher.running = true // prevent unexpected reloads
-
- accs := []accounts.Account{
- {
- Address: common.HexToAddress("095e7baea6a6c7c4c2dfeb977efac326af552d87"),
- URL: accounts.URL{Scheme: KeyStoreScheme, Path: "-309830980"},
- },
- {
- Address: common.HexToAddress("2cac1adea150210703ba75ed097ddfe24e14f213"),
- URL: accounts.URL{Scheme: KeyStoreScheme, Path: "ggg"},
- },
- {
- Address: common.HexToAddress("8bda78331c916a08481428e4b07c96d3e916d165"),
- URL: accounts.URL{Scheme: KeyStoreScheme, Path: "zzzzzz-the-very-last-one.keyXXX"},
- },
- {
- Address: common.HexToAddress("d49ff4eeb0b2686ed89c0fc0f2b6ea533ddbbd5e"),
- URL: accounts.URL{Scheme: KeyStoreScheme, Path: "SOMETHING.key"},
- },
- {
- Address: common.HexToAddress("7ef5a6135f1fd6a02593eedc869c6d41d934aef8"),
- URL: accounts.URL{Scheme: KeyStoreScheme, Path: "UTC--2016-03-22T12-57-55.920751759Z--7ef5a6135f1fd6a02593eedc869c6d41d934aef8"},
- },
- {
- Address: common.HexToAddress("f466859ead1932d743d622cb74fc058882e8648a"),
- URL: accounts.URL{Scheme: KeyStoreScheme, Path: "aaa"},
- },
- {
- Address: common.HexToAddress("289d485d9771714cce91d3393d764e1311907acc"),
- URL: accounts.URL{Scheme: KeyStoreScheme, Path: "zzz"},
- },
- }
- for _, a := range accs {
- cache.add(a)
- }
- // Add some of them twice to check that they don't get reinserted.
- cache.add(accs[0])
- cache.add(accs[2])
-
- // Check that the account list is sorted by filename.
- wantAccounts := make([]accounts.Account, len(accs))
- copy(wantAccounts, accs)
- slices.SortFunc(wantAccounts, byURL)
- list := cache.accounts()
- if !reflect.DeepEqual(list, wantAccounts) {
- t.Fatalf("got accounts: %s\nwant %s", spew.Sdump(accs), spew.Sdump(wantAccounts))
- }
- for _, a := range accs {
- if !cache.hasAddress(a.Address) {
- t.Errorf("expected hasAccount(%x) to return true", a.Address)
- }
- }
- if cache.hasAddress(common.HexToAddress("fd9bd350f08ee3c0c19b85a8e16114a11a60aa4e")) {
- t.Errorf("expected hasAccount(%x) to return false", common.HexToAddress("fd9bd350f08ee3c0c19b85a8e16114a11a60aa4e"))
- }
-
- // Delete a few keys from the cache.
- for i := 0; i < len(accs); i += 2 {
- cache.delete(wantAccounts[i])
- }
- cache.delete(accounts.Account{Address: common.HexToAddress("fd9bd350f08ee3c0c19b85a8e16114a11a60aa4e"), URL: accounts.URL{Scheme: KeyStoreScheme, Path: "something"}})
-
- // Check content again after deletion.
- wantAccountsAfterDelete := []accounts.Account{
- wantAccounts[1],
- wantAccounts[3],
- wantAccounts[5],
- }
- list = cache.accounts()
- if !reflect.DeepEqual(list, wantAccountsAfterDelete) {
- t.Fatalf("got accounts after delete: %s\nwant %s", spew.Sdump(list), spew.Sdump(wantAccountsAfterDelete))
- }
- for _, a := range wantAccountsAfterDelete {
- if !cache.hasAddress(a.Address) {
- t.Errorf("expected hasAccount(%x) to return true", a.Address)
- }
- }
- if cache.hasAddress(wantAccounts[0].Address) {
- t.Errorf("expected hasAccount(%x) to return false", wantAccounts[0].Address)
- }
-}
-
-func TestCacheFind(t *testing.T) {
- t.Parallel()
- dir := filepath.Join("testdata", "dir")
- cache, _ := newAccountCache(dir)
- cache.watcher.running = true // prevent unexpected reloads
-
- accs := []accounts.Account{
- {
- Address: common.HexToAddress("095e7baea6a6c7c4c2dfeb977efac326af552d87"),
- URL: accounts.URL{Scheme: KeyStoreScheme, Path: filepath.Join(dir, "a.key")},
- },
- {
- Address: common.HexToAddress("2cac1adea150210703ba75ed097ddfe24e14f213"),
- URL: accounts.URL{Scheme: KeyStoreScheme, Path: filepath.Join(dir, "b.key")},
- },
- {
- Address: common.HexToAddress("d49ff4eeb0b2686ed89c0fc0f2b6ea533ddbbd5e"),
- URL: accounts.URL{Scheme: KeyStoreScheme, Path: filepath.Join(dir, "c.key")},
- },
- {
- Address: common.HexToAddress("d49ff4eeb0b2686ed89c0fc0f2b6ea533ddbbd5e"),
- URL: accounts.URL{Scheme: KeyStoreScheme, Path: filepath.Join(dir, "c2.key")},
- },
- }
- for _, a := range accs {
- cache.add(a)
- }
-
- nomatchAccount := accounts.Account{
- Address: common.HexToAddress("f466859ead1932d743d622cb74fc058882e8648a"),
- URL: accounts.URL{Scheme: KeyStoreScheme, Path: filepath.Join(dir, "something")},
- }
- tests := []struct {
- Query accounts.Account
- WantResult accounts.Account
- WantError error
- }{
- // by address
- {Query: accounts.Account{Address: accs[0].Address}, WantResult: accs[0]},
- // by file
- {Query: accounts.Account{URL: accs[0].URL}, WantResult: accs[0]},
- // by basename
- {Query: accounts.Account{URL: accounts.URL{Scheme: KeyStoreScheme, Path: filepath.Base(accs[0].URL.Path)}}, WantResult: accs[0]},
- // by file and address
- {Query: accs[0], WantResult: accs[0]},
- // ambiguous address, tie resolved by file
- {Query: accs[2], WantResult: accs[2]},
- // ambiguous address error
- {
- Query: accounts.Account{Address: accs[2].Address},
- WantError: &AmbiguousAddrError{
- Addr: accs[2].Address,
- Matches: []accounts.Account{accs[2], accs[3]},
- },
- },
- // no match error
- {Query: nomatchAccount, WantError: ErrNoMatch},
- {Query: accounts.Account{URL: nomatchAccount.URL}, WantError: ErrNoMatch},
- {Query: accounts.Account{URL: accounts.URL{Scheme: KeyStoreScheme, Path: filepath.Base(nomatchAccount.URL.Path)}}, WantError: ErrNoMatch},
- {Query: accounts.Account{Address: nomatchAccount.Address}, WantError: ErrNoMatch},
- }
- for i, test := range tests {
- a, err := cache.find(test.Query)
- if !reflect.DeepEqual(err, test.WantError) {
- t.Errorf("test %d: error mismatch for query %v\ngot %q\nwant %q", i, test.Query, err, test.WantError)
- continue
- }
- if a != test.WantResult {
- t.Errorf("test %d: result mismatch for query %v\ngot %v\nwant %v", i, test.Query, a, test.WantResult)
- continue
- }
- }
-}
-
-// TestUpdatedKeyfileContents tests that updating the contents of a keystore file
-// is noticed by the watcher, and the account cache is updated accordingly
-func TestUpdatedKeyfileContents(t *testing.T) {
- t.Parallel()
-
- // Create a temporary keystore to test with
- dir := filepath.Join(os.TempDir(), fmt.Sprintf("eth-keystore-updatedkeyfilecontents-test-%d-%d", os.Getpid(), rand.Int()))
- ks := NewKeyStore(dir, LightScryptN, LightScryptP)
-
- list := ks.Accounts()
- if len(list) > 0 {
- t.Error("initial account list not empty:", list)
- }
- if !waitWatcherStart(ks) {
- t.Fatal("keystore watcher didn't start in time")
- }
- // Create the directory and copy a key file into it.
- os.MkdirAll(dir, 0700)
- defer os.RemoveAll(dir)
- file := filepath.Join(dir, "aaa")
-
- // Place one of our testfiles in there
- if err := cp.CopyFile(file, cachetestAccounts[0].URL.Path); err != nil {
- t.Fatal(err)
- }
-
- // ks should see the account.
- wantAccounts := []accounts.Account{cachetestAccounts[0]}
- wantAccounts[0].URL = accounts.URL{Scheme: KeyStoreScheme, Path: file}
- if err := waitForAccounts(wantAccounts, ks); err != nil {
- t.Error(err)
- return
- }
- // needed so that modTime of `file` is different to its current value after forceCopyFile
- os.Chtimes(file, time.Now().Add(-time.Second), time.Now().Add(-time.Second))
-
- // Now replace file contents
- if err := forceCopyFile(file, cachetestAccounts[1].URL.Path); err != nil {
- t.Fatal(err)
- return
- }
- wantAccounts = []accounts.Account{cachetestAccounts[1]}
- wantAccounts[0].URL = accounts.URL{Scheme: KeyStoreScheme, Path: file}
- if err := waitForAccounts(wantAccounts, ks); err != nil {
- t.Errorf("First replacement failed")
- t.Error(err)
- return
- }
-
- // needed so that modTime of `file` is different to its current value after forceCopyFile
- os.Chtimes(file, time.Now().Add(-time.Second), time.Now().Add(-time.Second))
-
- // Now replace file contents again
- if err := forceCopyFile(file, cachetestAccounts[2].URL.Path); err != nil {
- t.Fatal(err)
- return
- }
- wantAccounts = []accounts.Account{cachetestAccounts[2]}
- wantAccounts[0].URL = accounts.URL{Scheme: KeyStoreScheme, Path: file}
- if err := waitForAccounts(wantAccounts, ks); err != nil {
- t.Errorf("Second replacement failed")
- t.Error(err)
- return
- }
-
- // needed so that modTime of `file` is different to its current value after os.WriteFile
- os.Chtimes(file, time.Now().Add(-time.Second), time.Now().Add(-time.Second))
-
- // Now replace file contents with crap
- if err := os.WriteFile(file, []byte("foo"), 0600); err != nil {
- t.Fatal(err)
- return
- }
- if err := waitForAccounts([]accounts.Account{}, ks); err != nil {
- t.Errorf("Emptying account file failed")
- t.Error(err)
- return
- }
-}
-
-// forceCopyFile is like cp.CopyFile, but doesn't complain if the destination exists.
-func forceCopyFile(dst, src string) error {
- data, err := os.ReadFile(src)
- if err != nil {
- return err
- }
- return os.WriteFile(dst, data, 0644)
-}
diff --git a/accounts/keystore/file_cache.go b/accounts/keystore/file_cache.go
deleted file mode 100644
index 63eb850374..0000000000
--- a/accounts/keystore/file_cache.go
+++ /dev/null
@@ -1,105 +0,0 @@
-// 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 keystore
-
-import (
- "os"
- "path/filepath"
- "strings"
- "sync"
- "time"
-
- mapset "github.com/deckarep/golang-set/v2"
- "github.com/ethereum/go-ethereum/log"
-)
-
-// fileCache is a cache of files seen during scan of keystore.
-type fileCache struct {
- all mapset.Set[string] // Set of all files from the keystore folder
- lastMod time.Time // Last time instance when a file was modified
- mu sync.Mutex
-}
-
-// scan performs a new scan on the given directory, compares against the already
-// cached filenames, and returns file sets: creates, deletes, updates.
-func (fc *fileCache) scan(keyDir string) (mapset.Set[string], mapset.Set[string], mapset.Set[string], error) {
- t0 := time.Now()
-
- // List all the files from the keystore folder
- files, err := os.ReadDir(keyDir)
- if err != nil {
- return nil, nil, nil, err
- }
- t1 := time.Now()
-
- fc.mu.Lock()
- defer fc.mu.Unlock()
-
- // Iterate all the files and gather their metadata
- all := mapset.NewThreadUnsafeSet[string]()
- mods := mapset.NewThreadUnsafeSet[string]()
-
- var newLastMod time.Time
- for _, fi := range files {
- path := filepath.Join(keyDir, fi.Name())
- // Skip any non-key files from the folder
- if nonKeyFile(fi) {
- log.Trace("Ignoring file on account scan", "path", path)
- continue
- }
- // Gather the set of all and freshly modified files
- all.Add(path)
-
- info, err := fi.Info()
- if err != nil {
- return nil, nil, nil, err
- }
- modified := info.ModTime()
- if modified.After(fc.lastMod) {
- mods.Add(path)
- }
- if modified.After(newLastMod) {
- newLastMod = modified
- }
- }
- t2 := time.Now()
-
- // Update the tracked files and return the three sets
- deletes := fc.all.Difference(all) // Deletes = previous - current
- creates := all.Difference(fc.all) // Creates = current - previous
- updates := mods.Difference(creates) // Updates = modified - creates
-
- fc.all, fc.lastMod = all, newLastMod
- t3 := time.Now()
-
- // Report on the scanning stats and return
- log.Debug("FS scan times", "list", t1.Sub(t0), "set", t2.Sub(t1), "diff", t3.Sub(t2))
- return creates, deletes, updates, nil
-}
-
-// nonKeyFile ignores editor backups, hidden files and folders/symlinks.
-func nonKeyFile(fi os.DirEntry) bool {
- // Skip editor backups and UNIX-style hidden files.
- if strings.HasSuffix(fi.Name(), "~") || strings.HasPrefix(fi.Name(), ".") {
- return true
- }
- // Skip misc special files, directories (yes, symlinks too).
- if fi.IsDir() || !fi.Type().IsRegular() {
- return true
- }
- return false
-}
diff --git a/accounts/keystore/key.go b/accounts/keystore/key.go
deleted file mode 100644
index 9b2ac14712..0000000000
--- a/accounts/keystore/key.go
+++ /dev/null
@@ -1,237 +0,0 @@
-// Copyright 2014 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 keystore
-
-import (
- "bytes"
- "crypto/ecdsa"
- "encoding/hex"
- "encoding/json"
- "fmt"
- "io"
- "os"
- "path/filepath"
- "strings"
- "time"
-
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/google/uuid"
-)
-
-const (
- version = 3
-)
-
-type Key struct {
- Id uuid.UUID // Version 4 "random" for unique id not derived from key data
- // to simplify lookups we also store the address
- Address common.Address
- // we only store privkey as pubkey/address can be derived from it
- // privkey in this struct is always in plaintext
- PrivateKey *ecdsa.PrivateKey
-}
-
-type keyStore interface {
- // Loads and decrypts the key from disk.
- GetKey(addr common.Address, filename string, auth string) (*Key, error)
- // Writes and encrypts the key.
- StoreKey(filename string, k *Key, auth string) error
- // Joins filename with the key directory unless it is already absolute.
- JoinPath(filename string) string
-}
-
-type plainKeyJSON struct {
- Address string `json:"address"`
- PrivateKey string `json:"privatekey"`
- Id string `json:"id"`
- Version int `json:"version"`
-}
-
-type encryptedKeyJSONV3 struct {
- Address string `json:"address"`
- Crypto CryptoJSON `json:"crypto"`
- Id string `json:"id"`
- Version int `json:"version"`
-}
-
-type encryptedKeyJSONV1 struct {
- Address string `json:"address"`
- Crypto CryptoJSON `json:"crypto"`
- Id string `json:"id"`
- Version string `json:"version"`
-}
-
-type CryptoJSON struct {
- Cipher string `json:"cipher"`
- CipherText string `json:"ciphertext"`
- CipherParams cipherparamsJSON `json:"cipherparams"`
- KDF string `json:"kdf"`
- KDFParams map[string]interface{} `json:"kdfparams"`
- MAC string `json:"mac"`
-}
-
-type cipherparamsJSON struct {
- IV string `json:"iv"`
-}
-
-func (k *Key) MarshalJSON() (j []byte, err error) {
- jStruct := plainKeyJSON{
- hex.EncodeToString(k.Address[:]),
- hex.EncodeToString(crypto.FromECDSA(k.PrivateKey)),
- k.Id.String(),
- version,
- }
- j, err = json.Marshal(jStruct)
- return j, err
-}
-
-func (k *Key) UnmarshalJSON(j []byte) (err error) {
- keyJSON := new(plainKeyJSON)
- err = json.Unmarshal(j, &keyJSON)
- if err != nil {
- return err
- }
-
- u := new(uuid.UUID)
- *u, err = uuid.Parse(keyJSON.Id)
- if err != nil {
- return err
- }
- k.Id = *u
- addr, err := hex.DecodeString(keyJSON.Address)
- if err != nil {
- return err
- }
- privkey, err := crypto.HexToECDSA(keyJSON.PrivateKey)
- if err != nil {
- return err
- }
-
- k.Address = common.BytesToAddress(addr)
- k.PrivateKey = privkey
-
- return nil
-}
-
-func newKeyFromECDSA(privateKeyECDSA *ecdsa.PrivateKey) *Key {
- id, err := uuid.NewRandom()
- if err != nil {
- panic(fmt.Sprintf("Could not create random uuid: %v", err))
- }
- key := &Key{
- Id: id,
- Address: crypto.PubkeyToAddress(privateKeyECDSA.PublicKey),
- PrivateKey: privateKeyECDSA,
- }
- return key
-}
-
-// NewKeyForDirectICAP generates a key whose address fits into < 155 bits so it can fit
-// into the Direct ICAP spec. for simplicity and easier compatibility with other libs, we
-// retry until the first byte is 0.
-func NewKeyForDirectICAP(rand io.Reader) *Key {
- randBytes := make([]byte, 64)
- _, err := rand.Read(randBytes)
- if err != nil {
- panic("key generation: could not read from random source: " + err.Error())
- }
- reader := bytes.NewReader(randBytes)
- privateKeyECDSA, err := ecdsa.GenerateKey(crypto.S256(), reader)
- if err != nil {
- panic("key generation: ecdsa.GenerateKey failed: " + err.Error())
- }
- key := newKeyFromECDSA(privateKeyECDSA)
- if !strings.HasPrefix(key.Address.Hex(), "0x00") {
- return NewKeyForDirectICAP(rand)
- }
- return key
-}
-
-func newKey(rand io.Reader) (*Key, error) {
- privateKeyECDSA, err := ecdsa.GenerateKey(crypto.S256(), rand)
- if err != nil {
- return nil, err
- }
- return newKeyFromECDSA(privateKeyECDSA), nil
-}
-
-func storeNewKey(ks keyStore, rand io.Reader, auth string) (*Key, accounts.Account, error) {
- key, err := newKey(rand)
- if err != nil {
- return nil, accounts.Account{}, err
- }
- a := accounts.Account{
- Address: key.Address,
- URL: accounts.URL{Scheme: KeyStoreScheme, Path: ks.JoinPath(keyFileName(key.Address))},
- }
- if err := ks.StoreKey(a.URL.Path, key, auth); err != nil {
- zeroKey(key.PrivateKey)
- return nil, a, err
- }
- return key, a, err
-}
-
-func writeTemporaryKeyFile(file string, content []byte) (string, error) {
- // Create the keystore directory with appropriate permissions
- // in case it is not present yet.
- const dirPerm = 0700
- if err := os.MkdirAll(filepath.Dir(file), dirPerm); err != nil {
- return "", err
- }
- // Atomic write: create a temporary hidden file first
- // then move it into place. TempFile assigns mode 0600.
- f, err := os.CreateTemp(filepath.Dir(file), "."+filepath.Base(file)+".tmp")
- if err != nil {
- return "", err
- }
- if _, err := f.Write(content); err != nil {
- f.Close()
- os.Remove(f.Name())
- return "", err
- }
- f.Close()
- return f.Name(), nil
-}
-
-func writeKeyFile(file string, content []byte) error {
- name, err := writeTemporaryKeyFile(file, content)
- if err != nil {
- return err
- }
- return os.Rename(name, file)
-}
-
-// keyFileName implements the naming convention for keyfiles:
-// UTC---
-func keyFileName(keyAddr common.Address) string {
- ts := time.Now().UTC()
- return fmt.Sprintf("UTC--%s--%s", toISO8601(ts), hex.EncodeToString(keyAddr[:]))
-}
-
-func toISO8601(t time.Time) string {
- var tz string
- name, offset := t.Zone()
- if name == "UTC" {
- tz = "Z"
- } else {
- tz = fmt.Sprintf("%03d00", offset/3600)
- }
- return fmt.Sprintf("%04d-%02d-%02dT%02d-%02d-%02d.%09d%s",
- t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), tz)
-}
diff --git a/accounts/keystore/keystore.go b/accounts/keystore/keystore.go
deleted file mode 100644
index 0ffcf376a5..0000000000
--- a/accounts/keystore/keystore.go
+++ /dev/null
@@ -1,515 +0,0 @@
-// 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 keystore implements encrypted storage of secp256k1 private keys.
-//
-// Keys are stored as encrypted JSON files according to the Web3 Secret Storage specification.
-// See https://github.com/ethereum/wiki/wiki/Web3-Secret-Storage-Definition for more information.
-package keystore
-
-import (
- "crypto/ecdsa"
- crand "crypto/rand"
- "errors"
- "math/big"
- "os"
- "path/filepath"
- "reflect"
- "runtime"
- "sync"
- "time"
-
- "github.com/ethereum/go-ethereum/accounts"
- "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"
-)
-
-var (
- ErrLocked = accounts.NewAuthNeededError("password or unlock")
- ErrNoMatch = errors.New("no key for given address or file")
- ErrDecrypt = errors.New("could not decrypt key with given password")
-
- // ErrAccountAlreadyExists is returned if an account attempted to import is
- // already present in the keystore.
- ErrAccountAlreadyExists = errors.New("account already exists")
-)
-
-// KeyStoreType is the reflect type of a keystore backend.
-var KeyStoreType = reflect.TypeOf(&KeyStore{})
-
-// KeyStoreScheme is the protocol scheme prefixing account and wallet URLs.
-const KeyStoreScheme = "keystore"
-
-// Maximum time between wallet refreshes (if filesystem notifications don't work).
-const walletRefreshCycle = 3 * time.Second
-
-// KeyStore manages a key storage directory on disk.
-type KeyStore struct {
- storage keyStore // Storage backend, might be cleartext or encrypted
- cache *accountCache // In-memory account cache over the filesystem storage
- changes chan struct{} // Channel receiving change notifications from the cache
- unlocked map[common.Address]*unlocked // Currently unlocked account (decrypted private keys)
-
- wallets []accounts.Wallet // Wallet wrappers around the individual key files
- updateFeed event.Feed // Event feed to notify wallet additions/removals
- updateScope event.SubscriptionScope // Subscription scope tracking current live listeners
- updating bool // Whether the event notification loop is running
-
- mu sync.RWMutex
- importMu sync.Mutex // Import Mutex locks the import to prevent two insertions from racing
-}
-
-type unlocked struct {
- *Key
- abort chan struct{}
-}
-
-// NewKeyStore creates a keystore for the given directory.
-func NewKeyStore(keydir string, scryptN, scryptP int) *KeyStore {
- keydir, _ = filepath.Abs(keydir)
- ks := &KeyStore{storage: &keyStorePassphrase{keydir, scryptN, scryptP, false}}
- ks.init(keydir)
- return ks
-}
-
-// NewPlaintextKeyStore creates a keystore for the given directory.
-// Deprecated: Use NewKeyStore.
-func NewPlaintextKeyStore(keydir string) *KeyStore {
- keydir, _ = filepath.Abs(keydir)
- ks := &KeyStore{storage: &keyStorePlain{keydir}}
- ks.init(keydir)
- return ks
-}
-
-func (ks *KeyStore) init(keydir string) {
- // Lock the mutex since the account cache might call back with events
- ks.mu.Lock()
- defer ks.mu.Unlock()
-
- // Initialize the set of unlocked keys and the account cache
- ks.unlocked = make(map[common.Address]*unlocked)
- ks.cache, ks.changes = newAccountCache(keydir)
-
- // TODO: In order for this finalizer to work, there must be no references
- // to ks. addressCache doesn't keep a reference but unlocked keys do,
- // so the finalizer will not trigger until all timed unlocks have expired.
- runtime.SetFinalizer(ks, func(m *KeyStore) {
- m.cache.close()
- })
- // Create the initial list of wallets from the cache
- accs := ks.cache.accounts()
- ks.wallets = make([]accounts.Wallet, len(accs))
- for i := 0; i < len(accs); i++ {
- ks.wallets[i] = &keystoreWallet{account: accs[i], keystore: ks}
- }
-}
-
-// Wallets implements accounts.Backend, returning all single-key wallets from the
-// keystore directory.
-func (ks *KeyStore) Wallets() []accounts.Wallet {
- // Make sure the list of wallets is in sync with the account cache
- ks.refreshWallets()
-
- ks.mu.RLock()
- defer ks.mu.RUnlock()
-
- cpy := make([]accounts.Wallet, len(ks.wallets))
- copy(cpy, ks.wallets)
- return cpy
-}
-
-// refreshWallets retrieves the current account list and based on that does any
-// necessary wallet refreshes.
-func (ks *KeyStore) refreshWallets() {
- // Retrieve the current list of accounts
- ks.mu.Lock()
- accs := ks.cache.accounts()
-
- // Transform the current list of wallets into the new one
- var (
- wallets = make([]accounts.Wallet, 0, len(accs))
- events []accounts.WalletEvent
- )
-
- for _, account := range accs {
- // Drop wallets while they were in front of the next account
- for len(ks.wallets) > 0 && ks.wallets[0].URL().Cmp(account.URL) < 0 {
- events = append(events, accounts.WalletEvent{Wallet: ks.wallets[0], Kind: accounts.WalletDropped})
- ks.wallets = ks.wallets[1:]
- }
- // If there are no more wallets or the account is before the next, wrap new wallet
- if len(ks.wallets) == 0 || ks.wallets[0].URL().Cmp(account.URL) > 0 {
- wallet := &keystoreWallet{account: account, keystore: ks}
-
- events = append(events, accounts.WalletEvent{Wallet: wallet, Kind: accounts.WalletArrived})
- wallets = append(wallets, wallet)
- continue
- }
- // If the account is the same as the first wallet, keep it
- if ks.wallets[0].Accounts()[0] == account {
- wallets = append(wallets, ks.wallets[0])
- ks.wallets = ks.wallets[1:]
- continue
- }
- }
- // Drop any leftover wallets and set the new batch
- for _, wallet := range ks.wallets {
- events = append(events, accounts.WalletEvent{Wallet: wallet, Kind: accounts.WalletDropped})
- }
- ks.wallets = wallets
- ks.mu.Unlock()
-
- // Fire all wallet events and return
- for _, event := range events {
- ks.updateFeed.Send(event)
- }
-}
-
-// Subscribe implements accounts.Backend, creating an async subscription to
-// receive notifications on the addition or removal of keystore wallets.
-func (ks *KeyStore) Subscribe(sink chan<- accounts.WalletEvent) event.Subscription {
- // We need the mutex to reliably start/stop the update loop
- ks.mu.Lock()
- defer ks.mu.Unlock()
-
- // Subscribe the caller and track the subscriber count
- sub := ks.updateScope.Track(ks.updateFeed.Subscribe(sink))
-
- // Subscribers require an active notification loop, start it
- if !ks.updating {
- ks.updating = true
- go ks.updater()
- }
- return sub
-}
-
-// updater is responsible for maintaining an up-to-date list of wallets stored in
-// the keystore, and for firing wallet addition/removal events. It listens for
-// account change events from the underlying account cache, and also periodically
-// forces a manual refresh (only triggers for systems where the filesystem notifier
-// is not running).
-func (ks *KeyStore) updater() {
- for {
- // Wait for an account update or a refresh timeout
- select {
- case <-ks.changes:
- case <-time.After(walletRefreshCycle):
- }
- // Run the wallet refresher
- ks.refreshWallets()
-
- // If all our subscribers left, stop the updater
- ks.mu.Lock()
- if ks.updateScope.Count() == 0 {
- ks.updating = false
- ks.mu.Unlock()
- return
- }
- ks.mu.Unlock()
- }
-}
-
-// HasAddress reports whether a key with the given address is present.
-func (ks *KeyStore) HasAddress(addr common.Address) bool {
- return ks.cache.hasAddress(addr)
-}
-
-// Accounts returns all key files present in the directory.
-func (ks *KeyStore) Accounts() []accounts.Account {
- return ks.cache.accounts()
-}
-
-// Delete deletes the key matched by account if the passphrase is correct.
-// If the account contains no filename, the address must match a unique key.
-func (ks *KeyStore) Delete(a accounts.Account, passphrase string) error {
- // Decrypting the key isn't really necessary, but we do
- // it anyway to check the password and zero out the key
- // immediately afterwards.
- a, key, err := ks.getDecryptedKey(a, passphrase)
- if key != nil {
- zeroKey(key.PrivateKey)
- }
- if err != nil {
- return err
- }
- // The order is crucial here. The key is dropped from the
- // cache after the file is gone so that a reload happening in
- // between won't insert it into the cache again.
- err = os.Remove(a.URL.Path)
- if err == nil {
- ks.cache.delete(a)
- ks.refreshWallets()
- }
- return err
-}
-
-// SignHash calculates a ECDSA signature for the given hash. The produced
-// signature is in the [R || S || V] format where V is 0 or 1.
-func (ks *KeyStore) SignHash(a accounts.Account, hash []byte) ([]byte, error) {
- // Look up the key to sign with and abort if it cannot be found
- ks.mu.RLock()
- defer ks.mu.RUnlock()
-
- unlockedKey, found := ks.unlocked[a.Address]
- if !found {
- return nil, ErrLocked
- }
- // Sign the hash using plain ECDSA operations
- return crypto.Sign(hash, unlockedKey.PrivateKey)
-}
-
-// SignTx signs the given transaction with the requested account.
-func (ks *KeyStore) SignTx(a accounts.Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
- // Look up the key to sign with and abort if it cannot be found
- ks.mu.RLock()
- defer ks.mu.RUnlock()
-
- unlockedKey, found := ks.unlocked[a.Address]
- if !found {
- return nil, ErrLocked
- }
- // Depending on the presence of the chain ID, sign with 2718 or homestead
- signer := types.LatestSignerForChainID(chainID)
- return types.SignTx(tx, signer, unlockedKey.PrivateKey)
-}
-
-// SignHashWithPassphrase signs hash if the private key matching the given address
-// can be decrypted with the given passphrase. The produced signature is in the
-// [R || S || V] format where V is 0 or 1.
-func (ks *KeyStore) SignHashWithPassphrase(a accounts.Account, passphrase string, hash []byte) (signature []byte, err error) {
- _, key, err := ks.getDecryptedKey(a, passphrase)
- if err != nil {
- return nil, err
- }
- defer zeroKey(key.PrivateKey)
- return crypto.Sign(hash, key.PrivateKey)
-}
-
-// SignTxWithPassphrase signs the transaction if the private key matching the
-// given address can be decrypted with the given passphrase.
-func (ks *KeyStore) SignTxWithPassphrase(a accounts.Account, passphrase string, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
- _, key, err := ks.getDecryptedKey(a, passphrase)
- if err != nil {
- return nil, err
- }
- defer zeroKey(key.PrivateKey)
- // Depending on the presence of the chain ID, sign with or without replay protection.
- signer := types.LatestSignerForChainID(chainID)
- return types.SignTx(tx, signer, key.PrivateKey)
-}
-
-// Unlock unlocks the given account indefinitely.
-func (ks *KeyStore) Unlock(a accounts.Account, passphrase string) error {
- return ks.TimedUnlock(a, passphrase, 0)
-}
-
-// Lock removes the private key with the given address from memory.
-func (ks *KeyStore) Lock(addr common.Address) error {
- ks.mu.Lock()
- if unl, found := ks.unlocked[addr]; found {
- ks.mu.Unlock()
- ks.expire(addr, unl, time.Duration(0)*time.Nanosecond)
- } else {
- ks.mu.Unlock()
- }
- return nil
-}
-
-// TimedUnlock unlocks the given account with the passphrase. The account
-// stays unlocked for the duration of timeout. A timeout of 0 unlocks the account
-// until the program exits. The account must match a unique key file.
-//
-// If the account address is already unlocked for a duration, TimedUnlock extends or
-// shortens the active unlock timeout. If the address was previously unlocked
-// indefinitely the timeout is not altered.
-func (ks *KeyStore) TimedUnlock(a accounts.Account, passphrase string, timeout time.Duration) error {
- a, key, err := ks.getDecryptedKey(a, passphrase)
- if err != nil {
- return err
- }
-
- ks.mu.Lock()
- defer ks.mu.Unlock()
- u, found := ks.unlocked[a.Address]
- if found {
- if u.abort == nil {
- // The address was unlocked indefinitely, so unlocking
- // it with a timeout would be confusing.
- zeroKey(key.PrivateKey)
- return nil
- }
- // Terminate the expire goroutine and replace it below.
- close(u.abort)
- }
- if timeout > 0 {
- u = &unlocked{Key: key, abort: make(chan struct{})}
- go ks.expire(a.Address, u, timeout)
- } else {
- u = &unlocked{Key: key}
- }
- ks.unlocked[a.Address] = u
- return nil
-}
-
-// Find resolves the given account into a unique entry in the keystore.
-func (ks *KeyStore) Find(a accounts.Account) (accounts.Account, error) {
- ks.cache.maybeReload()
- ks.cache.mu.Lock()
- a, err := ks.cache.find(a)
- ks.cache.mu.Unlock()
- return a, err
-}
-
-func (ks *KeyStore) getDecryptedKey(a accounts.Account, auth string) (accounts.Account, *Key, error) {
- a, err := ks.Find(a)
- if err != nil {
- return a, nil, err
- }
- key, err := ks.storage.GetKey(a.Address, a.URL.Path, auth)
- return a, key, err
-}
-
-func (ks *KeyStore) expire(addr common.Address, u *unlocked, timeout time.Duration) {
- t := time.NewTimer(timeout)
- defer t.Stop()
- select {
- case <-u.abort:
- // just quit
- case <-t.C:
- ks.mu.Lock()
- // only drop if it's still the same key instance that dropLater
- // was launched with. we can check that using pointer equality
- // because the map stores a new pointer every time the key is
- // unlocked.
- if ks.unlocked[addr] == u {
- zeroKey(u.PrivateKey)
- delete(ks.unlocked, addr)
- }
- ks.mu.Unlock()
- }
-}
-
-// NewAccount generates a new key and stores it into the key directory,
-// encrypting it with the passphrase.
-func (ks *KeyStore) NewAccount(passphrase string) (accounts.Account, error) {
- _, account, err := storeNewKey(ks.storage, crand.Reader, passphrase)
- if err != nil {
- return accounts.Account{}, err
- }
- // Add the account to the cache immediately rather
- // than waiting for file system notifications to pick it up.
- ks.cache.add(account)
- ks.refreshWallets()
- return account, nil
-}
-
-// Export exports as a JSON key, encrypted with newPassphrase.
-func (ks *KeyStore) Export(a accounts.Account, passphrase, newPassphrase string) (keyJSON []byte, err error) {
- _, key, err := ks.getDecryptedKey(a, passphrase)
- if err != nil {
- return nil, err
- }
- var N, P int
- if store, ok := ks.storage.(*keyStorePassphrase); ok {
- N, P = store.scryptN, store.scryptP
- } else {
- N, P = StandardScryptN, StandardScryptP
- }
- return EncryptKey(key, newPassphrase, N, P)
-}
-
-// Import stores the given encrypted JSON key into the key directory.
-func (ks *KeyStore) Import(keyJSON []byte, passphrase, newPassphrase string) (accounts.Account, error) {
- key, err := DecryptKey(keyJSON, passphrase)
- if key != nil && key.PrivateKey != nil {
- defer zeroKey(key.PrivateKey)
- }
- if err != nil {
- return accounts.Account{}, err
- }
- ks.importMu.Lock()
- defer ks.importMu.Unlock()
-
- if ks.cache.hasAddress(key.Address) {
- return accounts.Account{
- Address: key.Address,
- }, ErrAccountAlreadyExists
- }
- return ks.importKey(key, newPassphrase)
-}
-
-// ImportECDSA stores the given key into the key directory, encrypting it with the passphrase.
-func (ks *KeyStore) ImportECDSA(priv *ecdsa.PrivateKey, passphrase string) (accounts.Account, error) {
- ks.importMu.Lock()
- defer ks.importMu.Unlock()
-
- key := newKeyFromECDSA(priv)
- if ks.cache.hasAddress(key.Address) {
- return accounts.Account{
- Address: key.Address,
- }, ErrAccountAlreadyExists
- }
- return ks.importKey(key, passphrase)
-}
-
-func (ks *KeyStore) importKey(key *Key, passphrase string) (accounts.Account, error) {
- a := accounts.Account{Address: key.Address, URL: accounts.URL{Scheme: KeyStoreScheme, Path: ks.storage.JoinPath(keyFileName(key.Address))}}
- if err := ks.storage.StoreKey(a.URL.Path, key, passphrase); err != nil {
- return accounts.Account{}, err
- }
- ks.cache.add(a)
- ks.refreshWallets()
- return a, nil
-}
-
-// Update changes the passphrase of an existing account.
-func (ks *KeyStore) Update(a accounts.Account, passphrase, newPassphrase string) error {
- a, key, err := ks.getDecryptedKey(a, passphrase)
- if err != nil {
- return err
- }
- return ks.storage.StoreKey(a.URL.Path, key, newPassphrase)
-}
-
-// ImportPreSaleKey decrypts the given Ethereum presale wallet and stores
-// a key file in the key directory. The key file is encrypted with the same passphrase.
-func (ks *KeyStore) ImportPreSaleKey(keyJSON []byte, passphrase string) (accounts.Account, error) {
- a, _, err := importPreSaleKey(ks.storage, keyJSON, passphrase)
- if err != nil {
- return a, err
- }
- ks.cache.add(a)
- ks.refreshWallets()
- return a, nil
-}
-
-// isUpdating returns whether the event notification loop is running.
-// This method is mainly meant for tests.
-func (ks *KeyStore) isUpdating() bool {
- ks.mu.RLock()
- defer ks.mu.RUnlock()
- return ks.updating
-}
-
-// zeroKey zeroes a private key in memory.
-func zeroKey(k *ecdsa.PrivateKey) {
- b := k.D.Bits()
- for i := range b {
- b[i] = 0
- }
-}
diff --git a/accounts/keystore/keystore_fuzzing_test.go b/accounts/keystore/keystore_fuzzing_test.go
deleted file mode 100644
index 793b46336a..0000000000
--- a/accounts/keystore/keystore_fuzzing_test.go
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright 2023 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 keystore
-
-import (
- "testing"
-)
-
-func FuzzPassword(f *testing.F) {
- f.Fuzz(func(t *testing.T, password string) {
- ks := NewKeyStore(t.TempDir(), LightScryptN, LightScryptP)
- a, err := ks.NewAccount(password)
- if err != nil {
- t.Fatal(err)
- }
- if err := ks.Unlock(a, password); err != nil {
- t.Fatal(err)
- }
- })
-}
diff --git a/accounts/keystore/keystore_test.go b/accounts/keystore/keystore_test.go
deleted file mode 100644
index c9a23eddd6..0000000000
--- a/accounts/keystore/keystore_test.go
+++ /dev/null
@@ -1,467 +0,0 @@
-// 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 keystore
-
-import (
- "math/rand"
- "os"
- "runtime"
- "strings"
- "sync"
- "sync/atomic"
- "testing"
- "time"
-
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/event"
- "golang.org/x/exp/slices"
-)
-
-var testSigData = make([]byte, 32)
-
-func TestKeyStore(t *testing.T) {
- t.Parallel()
- dir, ks := tmpKeyStore(t, true)
-
- a, err := ks.NewAccount("foo")
- if err != nil {
- t.Fatal(err)
- }
- if !strings.HasPrefix(a.URL.Path, dir) {
- t.Errorf("account file %s doesn't have dir prefix", a.URL)
- }
- stat, err := os.Stat(a.URL.Path)
- if err != nil {
- t.Fatalf("account file %s doesn't exist (%v)", a.URL, err)
- }
- if runtime.GOOS != "windows" && stat.Mode() != 0600 {
- t.Fatalf("account file has wrong mode: got %o, want %o", stat.Mode(), 0600)
- }
- if !ks.HasAddress(a.Address) {
- t.Errorf("HasAccount(%x) should've returned true", a.Address)
- }
- if err := ks.Update(a, "foo", "bar"); err != nil {
- t.Errorf("Update error: %v", err)
- }
- if err := ks.Delete(a, "bar"); err != nil {
- t.Errorf("Delete error: %v", err)
- }
- if common.FileExist(a.URL.Path) {
- t.Errorf("account file %s should be gone after Delete", a.URL)
- }
- if ks.HasAddress(a.Address) {
- t.Errorf("HasAccount(%x) should've returned true after Delete", a.Address)
- }
-}
-
-func TestSign(t *testing.T) {
- t.Parallel()
- _, ks := tmpKeyStore(t, true)
-
- pass := "" // not used but required by API
- a1, err := ks.NewAccount(pass)
- if err != nil {
- t.Fatal(err)
- }
- if err := ks.Unlock(a1, ""); err != nil {
- t.Fatal(err)
- }
- if _, err := ks.SignHash(accounts.Account{Address: a1.Address}, testSigData); err != nil {
- t.Fatal(err)
- }
-}
-
-func TestSignWithPassphrase(t *testing.T) {
- t.Parallel()
- _, ks := tmpKeyStore(t, true)
-
- pass := "passwd"
- acc, err := ks.NewAccount(pass)
- if err != nil {
- t.Fatal(err)
- }
-
- if _, unlocked := ks.unlocked[acc.Address]; unlocked {
- t.Fatal("expected account to be locked")
- }
-
- _, err = ks.SignHashWithPassphrase(acc, pass, testSigData)
- if err != nil {
- t.Fatal(err)
- }
-
- if _, unlocked := ks.unlocked[acc.Address]; unlocked {
- t.Fatal("expected account to be locked")
- }
-
- if _, err = ks.SignHashWithPassphrase(acc, "invalid passwd", testSigData); err == nil {
- t.Fatal("expected SignHashWithPassphrase to fail with invalid password")
- }
-}
-
-func TestTimedUnlock(t *testing.T) {
- t.Parallel()
- _, ks := tmpKeyStore(t, true)
-
- pass := "foo"
- a1, err := ks.NewAccount(pass)
- if err != nil {
- t.Fatal(err)
- }
-
- // Signing without passphrase fails because account is locked
- _, err = ks.SignHash(accounts.Account{Address: a1.Address}, testSigData)
- if err != ErrLocked {
- t.Fatal("Signing should've failed with ErrLocked before unlocking, got ", err)
- }
-
- // Signing with passphrase works
- if err = ks.TimedUnlock(a1, pass, 100*time.Millisecond); err != nil {
- t.Fatal(err)
- }
-
- // Signing without passphrase works because account is temp unlocked
- _, err = ks.SignHash(accounts.Account{Address: a1.Address}, testSigData)
- if err != nil {
- t.Fatal("Signing shouldn't return an error after unlocking, got ", err)
- }
-
- // Signing fails again after automatic locking
- time.Sleep(250 * time.Millisecond)
- _, err = ks.SignHash(accounts.Account{Address: a1.Address}, testSigData)
- if err != ErrLocked {
- t.Fatal("Signing should've failed with ErrLocked timeout expired, got ", err)
- }
-}
-
-func TestOverrideUnlock(t *testing.T) {
- t.Parallel()
- _, ks := tmpKeyStore(t, false)
-
- pass := "foo"
- a1, err := ks.NewAccount(pass)
- if err != nil {
- t.Fatal(err)
- }
-
- // Unlock indefinitely.
- if err = ks.TimedUnlock(a1, pass, 5*time.Minute); err != nil {
- t.Fatal(err)
- }
-
- // Signing without passphrase works because account is temp unlocked
- _, err = ks.SignHash(accounts.Account{Address: a1.Address}, testSigData)
- if err != nil {
- t.Fatal("Signing shouldn't return an error after unlocking, got ", err)
- }
-
- // reset unlock to a shorter period, invalidates the previous unlock
- if err = ks.TimedUnlock(a1, pass, 100*time.Millisecond); err != nil {
- t.Fatal(err)
- }
-
- // Signing without passphrase still works because account is temp unlocked
- _, err = ks.SignHash(accounts.Account{Address: a1.Address}, testSigData)
- if err != nil {
- t.Fatal("Signing shouldn't return an error after unlocking, got ", err)
- }
-
- // Signing fails again after automatic locking
- time.Sleep(250 * time.Millisecond)
- _, err = ks.SignHash(accounts.Account{Address: a1.Address}, testSigData)
- if err != ErrLocked {
- t.Fatal("Signing should've failed with ErrLocked timeout expired, got ", err)
- }
-}
-
-// This test should fail under -race if signing races the expiration goroutine.
-func TestSignRace(t *testing.T) {
- t.Parallel()
- _, ks := tmpKeyStore(t, false)
-
- // Create a test account.
- a1, err := ks.NewAccount("")
- if err != nil {
- t.Fatal("could not create the test account", err)
- }
-
- if err := ks.TimedUnlock(a1, "", 15*time.Millisecond); err != nil {
- t.Fatal("could not unlock the test account", err)
- }
- end := time.Now().Add(500 * time.Millisecond)
- for time.Now().Before(end) {
- if _, err := ks.SignHash(accounts.Account{Address: a1.Address}, testSigData); err == ErrLocked {
- return
- } else if err != nil {
- t.Errorf("Sign error: %v", err)
- return
- }
- time.Sleep(1 * time.Millisecond)
- }
- t.Errorf("Account did not lock within the timeout")
-}
-
-// waitForKsUpdating waits until the updating-status of the ks reaches the
-// desired wantStatus.
-// It waits for a maximum time of maxTime, and returns false if it does not
-// finish in time
-func waitForKsUpdating(t *testing.T, ks *KeyStore, wantStatus bool, maxTime time.Duration) bool {
- t.Helper()
- // Wait max 250 ms, then return false
- for t0 := time.Now(); time.Since(t0) < maxTime; {
- if ks.isUpdating() == wantStatus {
- return true
- }
- time.Sleep(25 * time.Millisecond)
- }
- return false
-}
-
-// Tests that the wallet notifier loop starts and stops correctly based on the
-// addition and removal of wallet event subscriptions.
-func TestWalletNotifierLifecycle(t *testing.T) {
- t.Parallel()
- // Create a temporary keystore to test with
- _, ks := tmpKeyStore(t, false)
-
- // Ensure that the notification updater is not running yet
- time.Sleep(250 * time.Millisecond)
-
- if ks.isUpdating() {
- t.Errorf("wallet notifier running without subscribers")
- }
- // Subscribe to the wallet feed and ensure the updater boots up
- updates := make(chan accounts.WalletEvent)
-
- subs := make([]event.Subscription, 2)
- for i := 0; i < len(subs); i++ {
- // Create a new subscription
- subs[i] = ks.Subscribe(updates)
- if !waitForKsUpdating(t, ks, true, 250*time.Millisecond) {
- t.Errorf("sub %d: wallet notifier not running after subscription", i)
- }
- }
- // Close all but one sub
- for i := 0; i < len(subs)-1; i++ {
- // Close an existing subscription
- subs[i].Unsubscribe()
- }
- // Check that it is still running
- time.Sleep(250 * time.Millisecond)
-
- if !ks.isUpdating() {
- t.Fatal("event notifier stopped prematurely")
- }
- // Unsubscribe the last one and ensure the updater terminates eventually.
- subs[len(subs)-1].Unsubscribe()
- if !waitForKsUpdating(t, ks, false, 4*time.Second) {
- t.Errorf("wallet notifier didn't terminate after unsubscribe")
- }
-}
-
-type walletEvent struct {
- accounts.WalletEvent
- a accounts.Account
-}
-
-// Tests that wallet notifications and correctly fired when accounts are added
-// or deleted from the keystore.
-func TestWalletNotifications(t *testing.T) {
- t.Parallel()
- _, ks := tmpKeyStore(t, false)
-
- // Subscribe to the wallet feed and collect events.
- var (
- events []walletEvent
- updates = make(chan accounts.WalletEvent)
- sub = ks.Subscribe(updates)
- )
- defer sub.Unsubscribe()
- go func() {
- for {
- select {
- case ev := <-updates:
- events = append(events, walletEvent{ev, ev.Wallet.Accounts()[0]})
- case <-sub.Err():
- close(updates)
- return
- }
- }
- }()
-
- // Randomly add and remove accounts.
- var (
- live = make(map[common.Address]accounts.Account)
- wantEvents []walletEvent
- )
- for i := 0; i < 1024; i++ {
- if create := len(live) == 0 || rand.Int()%4 > 0; create {
- // Add a new account and ensure wallet notifications arrives
- account, err := ks.NewAccount("")
- if err != nil {
- t.Fatalf("failed to create test account: %v", err)
- }
- live[account.Address] = account
- wantEvents = append(wantEvents, walletEvent{accounts.WalletEvent{Kind: accounts.WalletArrived}, account})
- } else {
- // Delete a random account.
- var account accounts.Account
- for _, a := range live {
- account = a
- break
- }
- if err := ks.Delete(account, ""); err != nil {
- t.Fatalf("failed to delete test account: %v", err)
- }
- delete(live, account.Address)
- wantEvents = append(wantEvents, walletEvent{accounts.WalletEvent{Kind: accounts.WalletDropped}, account})
- }
- }
-
- // Shut down the event collector and check events.
- sub.Unsubscribe()
- for ev := range updates {
- events = append(events, walletEvent{ev, ev.Wallet.Accounts()[0]})
- }
- checkAccounts(t, live, ks.Wallets())
- checkEvents(t, wantEvents, events)
-}
-
-// TestImportExport tests the import functionality of a keystore.
-func TestImportECDSA(t *testing.T) {
- t.Parallel()
- _, ks := tmpKeyStore(t, true)
- key, err := crypto.GenerateKey()
- if err != nil {
- t.Fatalf("failed to generate key: %v", key)
- }
- if _, err = ks.ImportECDSA(key, "old"); err != nil {
- t.Errorf("importing failed: %v", err)
- }
- if _, err = ks.ImportECDSA(key, "old"); err == nil {
- t.Errorf("importing same key twice succeeded")
- }
- if _, err = ks.ImportECDSA(key, "new"); err == nil {
- t.Errorf("importing same key twice succeeded")
- }
-}
-
-// TestImportECDSA tests the import and export functionality of a keystore.
-func TestImportExport(t *testing.T) {
- t.Parallel()
- _, ks := tmpKeyStore(t, true)
- acc, err := ks.NewAccount("old")
- if err != nil {
- t.Fatalf("failed to create account: %v", acc)
- }
- json, err := ks.Export(acc, "old", "new")
- if err != nil {
- t.Fatalf("failed to export account: %v", acc)
- }
- _, ks2 := tmpKeyStore(t, true)
- if _, err = ks2.Import(json, "old", "old"); err == nil {
- t.Errorf("importing with invalid password succeeded")
- }
- acc2, err := ks2.Import(json, "new", "new")
- if err != nil {
- t.Errorf("importing failed: %v", err)
- }
- if acc.Address != acc2.Address {
- t.Error("imported account does not match exported account")
- }
- if _, err = ks2.Import(json, "new", "new"); err == nil {
- t.Errorf("importing a key twice succeeded")
- }
-}
-
-// TestImportRace tests the keystore on races.
-// This test should fail under -race if importing races.
-func TestImportRace(t *testing.T) {
- t.Parallel()
- _, ks := tmpKeyStore(t, true)
- acc, err := ks.NewAccount("old")
- if err != nil {
- t.Fatalf("failed to create account: %v", acc)
- }
- json, err := ks.Export(acc, "old", "new")
- if err != nil {
- t.Fatalf("failed to export account: %v", acc)
- }
- _, ks2 := tmpKeyStore(t, true)
- var atom atomic.Uint32
- var wg sync.WaitGroup
- wg.Add(2)
- for i := 0; i < 2; i++ {
- go func() {
- defer wg.Done()
- if _, err := ks2.Import(json, "new", "new"); err != nil {
- atom.Add(1)
- }
- }()
- }
- wg.Wait()
- if atom.Load() != 1 {
- t.Errorf("Import is racy")
- }
-}
-
-// checkAccounts checks that all known live accounts are present in the wallet list.
-func checkAccounts(t *testing.T, live map[common.Address]accounts.Account, wallets []accounts.Wallet) {
- if len(live) != len(wallets) {
- t.Errorf("wallet list doesn't match required accounts: have %d, want %d", len(wallets), len(live))
- return
- }
- liveList := make([]accounts.Account, 0, len(live))
- for _, account := range live {
- liveList = append(liveList, account)
- }
- slices.SortFunc(liveList, byURL)
- for j, wallet := range wallets {
- if accs := wallet.Accounts(); len(accs) != 1 {
- t.Errorf("wallet %d: contains invalid number of accounts: have %d, want 1", j, len(accs))
- } else if accs[0] != liveList[j] {
- t.Errorf("wallet %d: account mismatch: have %v, want %v", j, accs[0], liveList[j])
- }
- }
-}
-
-// checkEvents checks that all events in 'want' are present in 'have'. Events may be present multiple times.
-func checkEvents(t *testing.T, want []walletEvent, have []walletEvent) {
- for _, wantEv := range want {
- nmatch := 0
- for ; len(have) > 0; nmatch++ {
- if have[0].Kind != wantEv.Kind || have[0].a != wantEv.a {
- break
- }
- have = have[1:]
- }
- if nmatch == 0 {
- t.Fatalf("can't find event with Kind=%v for %x", wantEv.Kind, wantEv.a.Address)
- }
- }
-}
-
-func tmpKeyStore(t *testing.T, encrypted bool) (string, *KeyStore) {
- d := t.TempDir()
- newKs := NewPlaintextKeyStore
- if encrypted {
- newKs = func(kd string) *KeyStore { return NewKeyStore(kd, veryLightScryptN, veryLightScryptP) }
- }
- return d, newKs(d)
-}
diff --git a/accounts/keystore/passphrase.go b/accounts/keystore/passphrase.go
deleted file mode 100644
index e7a7f8d0cb..0000000000
--- a/accounts/keystore/passphrase.go
+++ /dev/null
@@ -1,368 +0,0 @@
-// Copyright 2014 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 .
-
-/*
-
-This key store behaves as KeyStorePlain with the difference that
-the private key is encrypted and on disk uses another JSON encoding.
-
-The crypto is documented at https://github.com/ethereum/wiki/wiki/Web3-Secret-Storage-Definition
-
-*/
-
-package keystore
-
-import (
- "bytes"
- "crypto/aes"
- "crypto/rand"
- "crypto/sha256"
- "encoding/hex"
- "encoding/json"
- "fmt"
- "io"
- "os"
- "path/filepath"
-
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/google/uuid"
- "golang.org/x/crypto/pbkdf2"
- "golang.org/x/crypto/scrypt"
-)
-
-const (
- keyHeaderKDF = "scrypt"
-
- // StandardScryptN is the N parameter of Scrypt encryption algorithm, using 256MB
- // memory and taking approximately 1s CPU time on a modern processor.
- StandardScryptN = 1 << 18
-
- // StandardScryptP is the P parameter of Scrypt encryption algorithm, using 256MB
- // memory and taking approximately 1s CPU time on a modern processor.
- StandardScryptP = 1
-
- // LightScryptN is the N parameter of Scrypt encryption algorithm, using 4MB
- // memory and taking approximately 100ms CPU time on a modern processor.
- LightScryptN = 1 << 12
-
- // LightScryptP is the P parameter of Scrypt encryption algorithm, using 4MB
- // memory and taking approximately 100ms CPU time on a modern processor.
- LightScryptP = 6
-
- scryptR = 8
- scryptDKLen = 32
-)
-
-type keyStorePassphrase struct {
- keysDirPath string
- scryptN int
- scryptP int
- // skipKeyFileVerification disables the security-feature which does
- // reads and decrypts any newly created keyfiles. This should be 'false' in all
- // cases except tests -- setting this to 'true' is not recommended.
- skipKeyFileVerification bool
-}
-
-func (ks keyStorePassphrase) GetKey(addr common.Address, filename, auth string) (*Key, error) {
- // Load the key from the keystore and decrypt its contents
- keyjson, err := os.ReadFile(filename)
- if err != nil {
- return nil, err
- }
- key, err := DecryptKey(keyjson, auth)
- if err != nil {
- return nil, err
- }
- // Make sure we're really operating on the requested key (no swap attacks)
- if key.Address != addr {
- return nil, fmt.Errorf("key content mismatch: have account %x, want %x", key.Address, addr)
- }
- return key, nil
-}
-
-// StoreKey generates a key, encrypts with 'auth' and stores in the given directory
-func StoreKey(dir, auth string, scryptN, scryptP int) (accounts.Account, error) {
- _, a, err := storeNewKey(&keyStorePassphrase{dir, scryptN, scryptP, false}, rand.Reader, auth)
- return a, err
-}
-
-func (ks keyStorePassphrase) StoreKey(filename string, key *Key, auth string) error {
- keyjson, err := EncryptKey(key, auth, ks.scryptN, ks.scryptP)
- if err != nil {
- return err
- }
- // Write into temporary file
- tmpName, err := writeTemporaryKeyFile(filename, keyjson)
- if err != nil {
- return err
- }
- if !ks.skipKeyFileVerification {
- // Verify that we can decrypt the file with the given password.
- _, err = ks.GetKey(key.Address, tmpName, auth)
- if err != nil {
- msg := "An error was encountered when saving and verifying the keystore file. \n" +
- "This indicates that the keystore is corrupted. \n" +
- "The corrupted file is stored at \n%v\n" +
- "Please file a ticket at:\n\n" +
- "https://github.com/ethereum/go-ethereum/issues." +
- "The error was : %s"
- //lint:ignore ST1005 This is a message for the user
- return fmt.Errorf(msg, tmpName, err)
- }
- }
- return os.Rename(tmpName, filename)
-}
-
-func (ks keyStorePassphrase) JoinPath(filename string) string {
- if filepath.IsAbs(filename) {
- return filename
- }
- return filepath.Join(ks.keysDirPath, filename)
-}
-
-// EncryptDataV3 encrypts the data given as 'data' with the password 'auth'.
-func EncryptDataV3(data, auth []byte, scryptN, scryptP int) (CryptoJSON, error) {
- salt := make([]byte, 32)
- if _, err := io.ReadFull(rand.Reader, salt); err != nil {
- panic("reading from crypto/rand failed: " + err.Error())
- }
- derivedKey, err := scrypt.Key(auth, salt, scryptN, scryptR, scryptP, scryptDKLen)
- if err != nil {
- return CryptoJSON{}, err
- }
- encryptKey := derivedKey[:16]
-
- iv := make([]byte, aes.BlockSize) // 16
- if _, err := io.ReadFull(rand.Reader, iv); err != nil {
- panic("reading from crypto/rand failed: " + err.Error())
- }
- cipherText, err := aesCTRXOR(encryptKey, data, iv)
- if err != nil {
- return CryptoJSON{}, err
- }
- mac := crypto.Keccak256(derivedKey[16:32], cipherText)
-
- scryptParamsJSON := make(map[string]interface{}, 5)
- scryptParamsJSON["n"] = scryptN
- scryptParamsJSON["r"] = scryptR
- scryptParamsJSON["p"] = scryptP
- scryptParamsJSON["dklen"] = scryptDKLen
- scryptParamsJSON["salt"] = hex.EncodeToString(salt)
- cipherParamsJSON := cipherparamsJSON{
- IV: hex.EncodeToString(iv),
- }
-
- cryptoStruct := CryptoJSON{
- Cipher: "aes-128-ctr",
- CipherText: hex.EncodeToString(cipherText),
- CipherParams: cipherParamsJSON,
- KDF: keyHeaderKDF,
- KDFParams: scryptParamsJSON,
- MAC: hex.EncodeToString(mac),
- }
- return cryptoStruct, nil
-}
-
-// EncryptKey encrypts a key using the specified scrypt parameters into a json
-// blob that can be decrypted later on.
-func EncryptKey(key *Key, auth string, scryptN, scryptP int) ([]byte, error) {
- keyBytes := math.PaddedBigBytes(key.PrivateKey.D, 32)
- cryptoStruct, err := EncryptDataV3(keyBytes, []byte(auth), scryptN, scryptP)
- if err != nil {
- return nil, err
- }
- encryptedKeyJSONV3 := encryptedKeyJSONV3{
- hex.EncodeToString(key.Address[:]),
- cryptoStruct,
- key.Id.String(),
- version,
- }
- return json.Marshal(encryptedKeyJSONV3)
-}
-
-// DecryptKey decrypts a key from a json blob, returning the private key itself.
-func DecryptKey(keyjson []byte, auth string) (*Key, error) {
- // Parse the json into a simple map to fetch the key version
- m := make(map[string]interface{})
- if err := json.Unmarshal(keyjson, &m); err != nil {
- return nil, err
- }
- // Depending on the version try to parse one way or another
- var (
- keyBytes, keyId []byte
- err error
- )
- if version, ok := m["version"].(string); ok && version == "1" {
- k := new(encryptedKeyJSONV1)
- if err := json.Unmarshal(keyjson, k); err != nil {
- return nil, err
- }
- keyBytes, keyId, err = decryptKeyV1(k, auth)
- } else {
- k := new(encryptedKeyJSONV3)
- if err := json.Unmarshal(keyjson, k); err != nil {
- return nil, err
- }
- keyBytes, keyId, err = decryptKeyV3(k, auth)
- }
- // Handle any decryption errors and return the key
- if err != nil {
- return nil, err
- }
- key, err := crypto.ToECDSA(keyBytes)
- if err != nil {
- return nil, fmt.Errorf("invalid key: %w", err)
- }
- id, err := uuid.FromBytes(keyId)
- if err != nil {
- return nil, fmt.Errorf("invalid UUID: %w", err)
- }
- return &Key{
- Id: id,
- Address: crypto.PubkeyToAddress(key.PublicKey),
- PrivateKey: key,
- }, nil
-}
-
-func DecryptDataV3(cryptoJson CryptoJSON, auth string) ([]byte, error) {
- if cryptoJson.Cipher != "aes-128-ctr" {
- return nil, fmt.Errorf("cipher not supported: %v", cryptoJson.Cipher)
- }
- mac, err := hex.DecodeString(cryptoJson.MAC)
- if err != nil {
- return nil, err
- }
-
- iv, err := hex.DecodeString(cryptoJson.CipherParams.IV)
- if err != nil {
- return nil, err
- }
-
- cipherText, err := hex.DecodeString(cryptoJson.CipherText)
- if err != nil {
- return nil, err
- }
-
- derivedKey, err := getKDFKey(cryptoJson, auth)
- if err != nil {
- return nil, err
- }
-
- calculatedMAC := crypto.Keccak256(derivedKey[16:32], cipherText)
- if !bytes.Equal(calculatedMAC, mac) {
- return nil, ErrDecrypt
- }
-
- plainText, err := aesCTRXOR(derivedKey[:16], cipherText, iv)
- if err != nil {
- return nil, err
- }
- return plainText, err
-}
-
-func decryptKeyV3(keyProtected *encryptedKeyJSONV3, auth string) (keyBytes []byte, keyId []byte, err error) {
- if keyProtected.Version != version {
- return nil, nil, fmt.Errorf("version not supported: %v", keyProtected.Version)
- }
- keyUUID, err := uuid.Parse(keyProtected.Id)
- if err != nil {
- return nil, nil, err
- }
- keyId = keyUUID[:]
- plainText, err := DecryptDataV3(keyProtected.Crypto, auth)
- if err != nil {
- return nil, nil, err
- }
- return plainText, keyId, err
-}
-
-func decryptKeyV1(keyProtected *encryptedKeyJSONV1, auth string) (keyBytes []byte, keyId []byte, err error) {
- keyUUID, err := uuid.Parse(keyProtected.Id)
- if err != nil {
- return nil, nil, err
- }
- keyId = keyUUID[:]
- mac, err := hex.DecodeString(keyProtected.Crypto.MAC)
- if err != nil {
- return nil, nil, err
- }
-
- iv, err := hex.DecodeString(keyProtected.Crypto.CipherParams.IV)
- if err != nil {
- return nil, nil, err
- }
-
- cipherText, err := hex.DecodeString(keyProtected.Crypto.CipherText)
- if err != nil {
- return nil, nil, err
- }
-
- derivedKey, err := getKDFKey(keyProtected.Crypto, auth)
- if err != nil {
- return nil, nil, err
- }
-
- calculatedMAC := crypto.Keccak256(derivedKey[16:32], cipherText)
- if !bytes.Equal(calculatedMAC, mac) {
- return nil, nil, ErrDecrypt
- }
-
- plainText, err := aesCBCDecrypt(crypto.Keccak256(derivedKey[:16])[:16], cipherText, iv)
- if err != nil {
- return nil, nil, err
- }
- return plainText, keyId, err
-}
-
-func getKDFKey(cryptoJSON CryptoJSON, auth string) ([]byte, error) {
- authArray := []byte(auth)
- salt, err := hex.DecodeString(cryptoJSON.KDFParams["salt"].(string))
- if err != nil {
- return nil, err
- }
- dkLen := ensureInt(cryptoJSON.KDFParams["dklen"])
-
- if cryptoJSON.KDF == keyHeaderKDF {
- n := ensureInt(cryptoJSON.KDFParams["n"])
- r := ensureInt(cryptoJSON.KDFParams["r"])
- p := ensureInt(cryptoJSON.KDFParams["p"])
- return scrypt.Key(authArray, salt, n, r, p, dkLen)
- } else if cryptoJSON.KDF == "pbkdf2" {
- c := ensureInt(cryptoJSON.KDFParams["c"])
- prf := cryptoJSON.KDFParams["prf"].(string)
- if prf != "hmac-sha256" {
- return nil, fmt.Errorf("unsupported PBKDF2 PRF: %s", prf)
- }
- key := pbkdf2.Key(authArray, salt, c, dkLen, sha256.New)
- return key, nil
- }
-
- return nil, fmt.Errorf("unsupported KDF: %s", cryptoJSON.KDF)
-}
-
-// TODO: can we do without this when unmarshalling dynamic JSON?
-// why do integers in KDF params end up as float64 and not int after
-// unmarshal?
-func ensureInt(x interface{}) int {
- res, ok := x.(int)
- if !ok {
- res = int(x.(float64))
- }
- return res
-}
diff --git a/accounts/keystore/passphrase_test.go b/accounts/keystore/passphrase_test.go
deleted file mode 100644
index 20ec0f5519..0000000000
--- a/accounts/keystore/passphrase_test.go
+++ /dev/null
@@ -1,61 +0,0 @@
-// 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 keystore
-
-import (
- "os"
- "testing"
-
- "github.com/ethereum/go-ethereum/common"
-)
-
-const (
- veryLightScryptN = 2
- veryLightScryptP = 1
-)
-
-// Tests that a json key file can be decrypted and encrypted in multiple rounds.
-func TestKeyEncryptDecrypt(t *testing.T) {
- t.Parallel()
- keyjson, err := os.ReadFile("testdata/very-light-scrypt.json")
- if err != nil {
- t.Fatal(err)
- }
- password := ""
- address := common.HexToAddress("45dea0fb0bba44f4fcf290bba71fd57d7117cbb8")
-
- // Do a few rounds of decryption and encryption
- for i := 0; i < 3; i++ {
- // Try a bad password first
- if _, err := DecryptKey(keyjson, password+"bad"); err == nil {
- t.Errorf("test %d: json key decrypted with bad password", i)
- }
- // Decrypt with the correct password
- key, err := DecryptKey(keyjson, password)
- if err != nil {
- t.Fatalf("test %d: json key failed to decrypt: %v", i, err)
- }
- if key.Address != address {
- t.Errorf("test %d: key address mismatch: have %x, want %x", i, key.Address, address)
- }
- // Recrypt with a new password and start over
- password += "new data appended" // nolint: gosec
- if keyjson, err = EncryptKey(key, password, veryLightScryptN, veryLightScryptP); err != nil {
- t.Errorf("test %d: failed to re-encrypt key %v", i, err)
- }
- }
-}
diff --git a/accounts/keystore/plain.go b/accounts/keystore/plain.go
deleted file mode 100644
index f62a133ce1..0000000000
--- a/accounts/keystore/plain.go
+++ /dev/null
@@ -1,61 +0,0 @@
-// 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 keystore
-
-import (
- "encoding/json"
- "fmt"
- "os"
- "path/filepath"
-
- "github.com/ethereum/go-ethereum/common"
-)
-
-type keyStorePlain struct {
- keysDirPath string
-}
-
-func (ks keyStorePlain) GetKey(addr common.Address, filename, auth string) (*Key, error) {
- fd, err := os.Open(filename)
- if err != nil {
- return nil, err
- }
- defer fd.Close()
- key := new(Key)
- if err := json.NewDecoder(fd).Decode(key); err != nil {
- return nil, err
- }
- if key.Address != addr {
- return nil, fmt.Errorf("key content mismatch: have address %x, want %x", key.Address, addr)
- }
- return key, nil
-}
-
-func (ks keyStorePlain) StoreKey(filename string, key *Key, auth string) error {
- content, err := json.Marshal(key)
- if err != nil {
- return err
- }
- return writeKeyFile(filename, content)
-}
-
-func (ks keyStorePlain) JoinPath(filename string) string {
- if filepath.IsAbs(filename) {
- return filename
- }
- return filepath.Join(ks.keysDirPath, filename)
-}
diff --git a/accounts/keystore/plain_test.go b/accounts/keystore/plain_test.go
deleted file mode 100644
index 737eb7fd61..0000000000
--- a/accounts/keystore/plain_test.go
+++ /dev/null
@@ -1,261 +0,0 @@
-// Copyright 2014 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 keystore
-
-import (
- "crypto/rand"
- "encoding/hex"
- "fmt"
- "path/filepath"
- "reflect"
- "strings"
- "testing"
-
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/crypto"
-)
-
-func tmpKeyStoreIface(t *testing.T, encrypted bool) (dir string, ks keyStore) {
- d := t.TempDir()
- if encrypted {
- ks = &keyStorePassphrase{d, veryLightScryptN, veryLightScryptP, true}
- } else {
- ks = &keyStorePlain{d}
- }
- return d, ks
-}
-
-func TestKeyStorePlain(t *testing.T) {
- t.Parallel()
- _, ks := tmpKeyStoreIface(t, false)
-
- pass := "" // not used but required by API
- k1, account, err := storeNewKey(ks, rand.Reader, pass)
- if err != nil {
- t.Fatal(err)
- }
- k2, err := ks.GetKey(k1.Address, account.URL.Path, pass)
- if err != nil {
- t.Fatal(err)
- }
- if !reflect.DeepEqual(k1.Address, k2.Address) {
- t.Fatal(err)
- }
- if !reflect.DeepEqual(k1.PrivateKey, k2.PrivateKey) {
- t.Fatal(err)
- }
-}
-
-func TestKeyStorePassphrase(t *testing.T) {
- t.Parallel()
- _, ks := tmpKeyStoreIface(t, true)
-
- pass := "foo"
- k1, account, err := storeNewKey(ks, rand.Reader, pass)
- if err != nil {
- t.Fatal(err)
- }
- k2, err := ks.GetKey(k1.Address, account.URL.Path, pass)
- if err != nil {
- t.Fatal(err)
- }
- if !reflect.DeepEqual(k1.Address, k2.Address) {
- t.Fatal(err)
- }
- if !reflect.DeepEqual(k1.PrivateKey, k2.PrivateKey) {
- t.Fatal(err)
- }
-}
-
-func TestKeyStorePassphraseDecryptionFail(t *testing.T) {
- t.Parallel()
- _, ks := tmpKeyStoreIface(t, true)
-
- pass := "foo"
- k1, account, err := storeNewKey(ks, rand.Reader, pass)
- if err != nil {
- t.Fatal(err)
- }
- if _, err = ks.GetKey(k1.Address, account.URL.Path, "bar"); err != ErrDecrypt {
- t.Fatalf("wrong error for invalid password\ngot %q\nwant %q", err, ErrDecrypt)
- }
-}
-
-func TestImportPreSaleKey(t *testing.T) {
- t.Parallel()
- dir, ks := tmpKeyStoreIface(t, true)
-
- // file content of a presale key file generated with:
- // python pyethsaletool.py genwallet
- // with password "foo"
- fileContent := "{\"encseed\": \"26d87f5f2bf9835f9a47eefae571bc09f9107bb13d54ff12a4ec095d01f83897494cf34f7bed2ed34126ecba9db7b62de56c9d7cd136520a0427bfb11b8954ba7ac39b90d4650d3448e31185affcd74226a68f1e94b1108e6e0a4a91cdd83eba\", \"ethaddr\": \"d4584b5f6229b7be90727b0fc8c6b91bb427821f\", \"email\": \"gustav.simonsson@gmail.com\", \"btcaddr\": \"1EVknXyFC68kKNLkh6YnKzW41svSRoaAcx\"}"
- pass := "foo"
- account, _, err := importPreSaleKey(ks, []byte(fileContent), pass)
- if err != nil {
- t.Fatal(err)
- }
- if account.Address != common.HexToAddress("d4584b5f6229b7be90727b0fc8c6b91bb427821f") {
- t.Errorf("imported account has wrong address %x", account.Address)
- }
- if !strings.HasPrefix(account.URL.Path, dir) {
- t.Errorf("imported account file not in keystore directory: %q", account.URL)
- }
-}
-
-// Test and utils for the key store tests in the Ethereum JSON tests;
-// testdataKeyStoreTests/basic_tests.json
-type KeyStoreTestV3 struct {
- Json encryptedKeyJSONV3
- Password string
- Priv string
-}
-
-type KeyStoreTestV1 struct {
- Json encryptedKeyJSONV1
- Password string
- Priv string
-}
-
-func TestV3_PBKDF2_1(t *testing.T) {
- t.Parallel()
- tests := loadKeyStoreTestV3("testdata/v3_test_vector.json", t)
- testDecryptV3(tests["wikipage_test_vector_pbkdf2"], t)
-}
-
-var testsSubmodule = filepath.Join("..", "..", "tests", "testdata", "KeyStoreTests")
-
-func skipIfSubmoduleMissing(t *testing.T) {
- if !common.FileExist(testsSubmodule) {
- t.Skipf("can't find JSON tests from submodule at %s", testsSubmodule)
- }
-}
-
-func TestV3_PBKDF2_2(t *testing.T) {
- skipIfSubmoduleMissing(t)
- t.Parallel()
- tests := loadKeyStoreTestV3(filepath.Join(testsSubmodule, "basic_tests.json"), t)
- testDecryptV3(tests["test1"], t)
-}
-
-func TestV3_PBKDF2_3(t *testing.T) {
- skipIfSubmoduleMissing(t)
- t.Parallel()
- tests := loadKeyStoreTestV3(filepath.Join(testsSubmodule, "basic_tests.json"), t)
- testDecryptV3(tests["python_generated_test_with_odd_iv"], t)
-}
-
-func TestV3_PBKDF2_4(t *testing.T) {
- skipIfSubmoduleMissing(t)
- t.Parallel()
- tests := loadKeyStoreTestV3(filepath.Join(testsSubmodule, "basic_tests.json"), t)
- testDecryptV3(tests["evilnonce"], t)
-}
-
-func TestV3_Scrypt_1(t *testing.T) {
- t.Parallel()
- tests := loadKeyStoreTestV3("testdata/v3_test_vector.json", t)
- testDecryptV3(tests["wikipage_test_vector_scrypt"], t)
-}
-
-func TestV3_Scrypt_2(t *testing.T) {
- skipIfSubmoduleMissing(t)
- t.Parallel()
- tests := loadKeyStoreTestV3(filepath.Join(testsSubmodule, "basic_tests.json"), t)
- testDecryptV3(tests["test2"], t)
-}
-
-func TestV1_1(t *testing.T) {
- t.Parallel()
- tests := loadKeyStoreTestV1("testdata/v1_test_vector.json", t)
- testDecryptV1(tests["test1"], t)
-}
-
-func TestV1_2(t *testing.T) {
- t.Parallel()
- ks := &keyStorePassphrase{"testdata/v1", LightScryptN, LightScryptP, true}
- addr := common.HexToAddress("cb61d5a9c4896fb9658090b597ef0e7be6f7b67e")
- file := "testdata/v1/cb61d5a9c4896fb9658090b597ef0e7be6f7b67e/cb61d5a9c4896fb9658090b597ef0e7be6f7b67e"
- k, err := ks.GetKey(addr, file, "g")
- if err != nil {
- t.Fatal(err)
- }
- privHex := hex.EncodeToString(crypto.FromECDSA(k.PrivateKey))
- expectedHex := "d1b1178d3529626a1a93e073f65028370d14c7eb0936eb42abef05db6f37ad7d"
- if privHex != expectedHex {
- t.Fatal(fmt.Errorf("Unexpected privkey: %v, expected %v", privHex, expectedHex))
- }
-}
-
-func testDecryptV3(test KeyStoreTestV3, t *testing.T) {
- privBytes, _, err := decryptKeyV3(&test.Json, test.Password)
- if err != nil {
- t.Fatal(err)
- }
- privHex := hex.EncodeToString(privBytes)
- if test.Priv != privHex {
- t.Fatal(fmt.Errorf("Decrypted bytes not equal to test, expected %v have %v", test.Priv, privHex))
- }
-}
-
-func testDecryptV1(test KeyStoreTestV1, t *testing.T) {
- privBytes, _, err := decryptKeyV1(&test.Json, test.Password)
- if err != nil {
- t.Fatal(err)
- }
- privHex := hex.EncodeToString(privBytes)
- if test.Priv != privHex {
- t.Fatal(fmt.Errorf("Decrypted bytes not equal to test, expected %v have %v", test.Priv, privHex))
- }
-}
-
-func loadKeyStoreTestV3(file string, t *testing.T) map[string]KeyStoreTestV3 {
- tests := make(map[string]KeyStoreTestV3)
- err := common.LoadJSON(file, &tests)
- if err != nil {
- t.Fatal(err)
- }
- return tests
-}
-
-func loadKeyStoreTestV1(file string, t *testing.T) map[string]KeyStoreTestV1 {
- tests := make(map[string]KeyStoreTestV1)
- err := common.LoadJSON(file, &tests)
- if err != nil {
- t.Fatal(err)
- }
- return tests
-}
-
-func TestKeyForDirectICAP(t *testing.T) {
- t.Parallel()
- key := NewKeyForDirectICAP(rand.Reader)
- if !strings.HasPrefix(key.Address.Hex(), "0x00") {
- t.Errorf("Expected first address byte to be zero, have: %s", key.Address.Hex())
- }
-}
-
-func TestV3_31_Byte_Key(t *testing.T) {
- t.Parallel()
- tests := loadKeyStoreTestV3("testdata/v3_test_vector.json", t)
- testDecryptV3(tests["31_byte_key"], t)
-}
-
-func TestV3_30_Byte_Key(t *testing.T) {
- t.Parallel()
- tests := loadKeyStoreTestV3("testdata/v3_test_vector.json", t)
- testDecryptV3(tests["30_byte_key"], t)
-}
diff --git a/accounts/keystore/presale.go b/accounts/keystore/presale.go
deleted file mode 100644
index 0664dc2cdd..0000000000
--- a/accounts/keystore/presale.go
+++ /dev/null
@@ -1,150 +0,0 @@
-// 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 keystore
-
-import (
- "crypto/aes"
- "crypto/cipher"
- "crypto/sha256"
- "encoding/hex"
- "encoding/json"
- "errors"
- "fmt"
-
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/google/uuid"
- "golang.org/x/crypto/pbkdf2"
-)
-
-// creates a Key and stores that in the given KeyStore by decrypting a presale key JSON
-func importPreSaleKey(keyStore keyStore, keyJSON []byte, password string) (accounts.Account, *Key, error) {
- key, err := decryptPreSaleKey(keyJSON, password)
- if err != nil {
- return accounts.Account{}, nil, err
- }
- key.Id, err = uuid.NewRandom()
- if err != nil {
- return accounts.Account{}, nil, err
- }
- a := accounts.Account{
- Address: key.Address,
- URL: accounts.URL{
- Scheme: KeyStoreScheme,
- Path: keyStore.JoinPath(keyFileName(key.Address)),
- },
- }
- err = keyStore.StoreKey(a.URL.Path, key, password)
- return a, key, err
-}
-
-func decryptPreSaleKey(fileContent []byte, password string) (key *Key, err error) {
- preSaleKeyStruct := struct {
- EncSeed string
- EthAddr string
- Email string
- BtcAddr string
- }{}
- err = json.Unmarshal(fileContent, &preSaleKeyStruct)
- if err != nil {
- return nil, err
- }
- encSeedBytes, err := hex.DecodeString(preSaleKeyStruct.EncSeed)
- if err != nil {
- return nil, errors.New("invalid hex in encSeed")
- }
- if len(encSeedBytes) < 16 {
- return nil, errors.New("invalid encSeed, too short")
- }
- iv := encSeedBytes[:16]
- cipherText := encSeedBytes[16:]
- /*
- See https://github.com/ethereum/pyethsaletool
-
- pyethsaletool generates the encryption key from password by
- 2000 rounds of PBKDF2 with HMAC-SHA-256 using password as salt (:().
- 16 byte key length within PBKDF2 and resulting key is used as AES key
- */
- passBytes := []byte(password)
- derivedKey := pbkdf2.Key(passBytes, passBytes, 2000, 16, sha256.New)
- plainText, err := aesCBCDecrypt(derivedKey, cipherText, iv)
- if err != nil {
- return nil, err
- }
- ethPriv := crypto.Keccak256(plainText)
- ecKey := crypto.ToECDSAUnsafe(ethPriv)
-
- key = &Key{
- Id: uuid.UUID{},
- Address: crypto.PubkeyToAddress(ecKey.PublicKey),
- PrivateKey: ecKey,
- }
- derivedAddr := hex.EncodeToString(key.Address.Bytes()) // needed because .Hex() gives leading "0x"
- expectedAddr := preSaleKeyStruct.EthAddr
- if derivedAddr != expectedAddr {
- err = fmt.Errorf("decrypted addr '%s' not equal to expected addr '%s'", derivedAddr, expectedAddr)
- }
- return key, err
-}
-
-func aesCTRXOR(key, inText, iv []byte) ([]byte, error) {
- // AES-128 is selected due to size of encryptKey.
- aesBlock, err := aes.NewCipher(key)
- if err != nil {
- return nil, err
- }
- stream := cipher.NewCTR(aesBlock, iv)
- outText := make([]byte, len(inText))
- stream.XORKeyStream(outText, inText)
- return outText, err
-}
-
-func aesCBCDecrypt(key, cipherText, iv []byte) ([]byte, error) {
- aesBlock, err := aes.NewCipher(key)
- if err != nil {
- return nil, err
- }
- decrypter := cipher.NewCBCDecrypter(aesBlock, iv)
- paddedPlaintext := make([]byte, len(cipherText))
- decrypter.CryptBlocks(paddedPlaintext, cipherText)
- plaintext := pkcs7Unpad(paddedPlaintext)
- if plaintext == nil {
- return nil, ErrDecrypt
- }
- return plaintext, err
-}
-
-// From https://leanpub.com/gocrypto/read#leanpub-auto-block-cipher-modes
-func pkcs7Unpad(in []byte) []byte {
- if len(in) == 0 {
- return nil
- }
-
- padding := in[len(in)-1]
- if int(padding) > len(in) || padding > aes.BlockSize {
- return nil
- } else if padding == 0 {
- return nil
- }
-
- for i := len(in) - 1; i > len(in)-int(padding)-1; i-- {
- if in[i] != padding {
- return nil
- }
- }
- return in[:len(in)-int(padding)]
-}
diff --git a/accounts/keystore/testdata/dupes/1 b/accounts/keystore/testdata/dupes/1
deleted file mode 100644
index a3868ec6d5..0000000000
--- a/accounts/keystore/testdata/dupes/1
+++ /dev/null
@@ -1 +0,0 @@
-{"address":"f466859ead1932d743d622cb74fc058882e8648a","crypto":{"cipher":"aes-128-ctr","ciphertext":"cb664472deacb41a2e995fa7f96fe29ce744471deb8d146a0e43c7898c9ddd4d","cipherparams":{"iv":"dfd9ee70812add5f4b8f89d0811c9158"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"0d6769bf016d45c479213990d6a08d938469c4adad8a02ce507b4a4e7b7739f1"},"mac":"bac9af994b15a45dd39669fc66f9aa8a3b9dd8c22cb16e4d8d7ea089d0f1a1a9"},"id":"472e8b3d-afb6-45b5-8111-72c89895099a","version":3}
\ No newline at end of file
diff --git a/accounts/keystore/testdata/dupes/2 b/accounts/keystore/testdata/dupes/2
deleted file mode 100644
index a3868ec6d5..0000000000
--- a/accounts/keystore/testdata/dupes/2
+++ /dev/null
@@ -1 +0,0 @@
-{"address":"f466859ead1932d743d622cb74fc058882e8648a","crypto":{"cipher":"aes-128-ctr","ciphertext":"cb664472deacb41a2e995fa7f96fe29ce744471deb8d146a0e43c7898c9ddd4d","cipherparams":{"iv":"dfd9ee70812add5f4b8f89d0811c9158"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"0d6769bf016d45c479213990d6a08d938469c4adad8a02ce507b4a4e7b7739f1"},"mac":"bac9af994b15a45dd39669fc66f9aa8a3b9dd8c22cb16e4d8d7ea089d0f1a1a9"},"id":"472e8b3d-afb6-45b5-8111-72c89895099a","version":3}
\ No newline at end of file
diff --git a/accounts/keystore/testdata/dupes/foo b/accounts/keystore/testdata/dupes/foo
deleted file mode 100644
index c57060aea0..0000000000
--- a/accounts/keystore/testdata/dupes/foo
+++ /dev/null
@@ -1 +0,0 @@
-{"address":"7ef5a6135f1fd6a02593eedc869c6d41d934aef8","crypto":{"cipher":"aes-128-ctr","ciphertext":"1d0839166e7a15b9c1333fc865d69858b22df26815ccf601b28219b6192974e1","cipherparams":{"iv":"8df6caa7ff1b00c4e871f002cb7921ed"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"e5e6ef3f4ea695f496b643ebd3f75c0aa58ef4070e90c80c5d3fb0241bf1595c"},"mac":"6d16dfde774845e4585357f24bce530528bc69f4f84e1e22880d34fa45c273e5"},"id":"950077c7-71e3-4c44-a4a1-143919141ed4","version":3}
\ No newline at end of file
diff --git a/accounts/keystore/testdata/keystore/.hiddenfile b/accounts/keystore/testdata/keystore/.hiddenfile
deleted file mode 100644
index d91faccdeb..0000000000
--- a/accounts/keystore/testdata/keystore/.hiddenfile
+++ /dev/null
@@ -1 +0,0 @@
-{"address":"f466859ead1932d743d622cb74fc058882e8648a","crypto":{"cipher":"aes-128-ctr","ciphertext":"cb664472deacb41a2e995fa7f96fe29ce744471deb8d146a0e43c7898c9ddd4d","cipherparams":{"iv":"dfd9ee70812add5f4b8f89d0811c9158"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"0d6769bf016d45c479213990d6a08d938469c4adad8a02ce507b4a4e7b7739f1"},"mac":"bac9af994b15a45dd39669fc66f9aa8a3b9dd8c22cb16e4d8d7ea089d0f1a1a9"},"id":"472e8b3d-afb6-45b5-8111-72c89895099a","version":3}
diff --git a/accounts/keystore/testdata/keystore/README b/accounts/keystore/testdata/keystore/README
deleted file mode 100644
index 6af9ac3f1b..0000000000
--- a/accounts/keystore/testdata/keystore/README
+++ /dev/null
@@ -1,21 +0,0 @@
-This directory contains accounts for testing.
-The password that unlocks them is "foobar".
-
-The "good" key files which are supposed to be loadable are:
-
-- File: UTC--2016-03-22T12-57-55.920751759Z--7ef5a6135f1fd6a02593eedc869c6d41d934aef8
- Address: 0x7ef5a6135f1fd6a02593eedc869c6d41d934aef8
-- File: aaa
- Address: 0xf466859ead1932d743d622cb74fc058882e8648a
-- File: zzz
- Address: 0x289d485d9771714cce91d3393d764e1311907acc
-
-The other files (including this README) are broken in various ways
-and should not be picked up by package accounts:
-
-- File: no-address (missing address field, otherwise same as "aaa")
-- File: garbage (file with random data)
-- File: empty (file with no content)
-- File: swapfile~ (should be skipped)
-- File: .hiddenfile (should be skipped)
-- File: foo/... (should be skipped because it is a directory)
diff --git a/accounts/keystore/testdata/keystore/UTC--2016-03-22T12-57-55.920751759Z--7ef5a6135f1fd6a02593eedc869c6d41d934aef8 b/accounts/keystore/testdata/keystore/UTC--2016-03-22T12-57-55.920751759Z--7ef5a6135f1fd6a02593eedc869c6d41d934aef8
deleted file mode 100644
index c57060aea0..0000000000
--- a/accounts/keystore/testdata/keystore/UTC--2016-03-22T12-57-55.920751759Z--7ef5a6135f1fd6a02593eedc869c6d41d934aef8
+++ /dev/null
@@ -1 +0,0 @@
-{"address":"7ef5a6135f1fd6a02593eedc869c6d41d934aef8","crypto":{"cipher":"aes-128-ctr","ciphertext":"1d0839166e7a15b9c1333fc865d69858b22df26815ccf601b28219b6192974e1","cipherparams":{"iv":"8df6caa7ff1b00c4e871f002cb7921ed"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"e5e6ef3f4ea695f496b643ebd3f75c0aa58ef4070e90c80c5d3fb0241bf1595c"},"mac":"6d16dfde774845e4585357f24bce530528bc69f4f84e1e22880d34fa45c273e5"},"id":"950077c7-71e3-4c44-a4a1-143919141ed4","version":3}
\ No newline at end of file
diff --git a/accounts/keystore/testdata/keystore/aaa b/accounts/keystore/testdata/keystore/aaa
deleted file mode 100644
index a3868ec6d5..0000000000
--- a/accounts/keystore/testdata/keystore/aaa
+++ /dev/null
@@ -1 +0,0 @@
-{"address":"f466859ead1932d743d622cb74fc058882e8648a","crypto":{"cipher":"aes-128-ctr","ciphertext":"cb664472deacb41a2e995fa7f96fe29ce744471deb8d146a0e43c7898c9ddd4d","cipherparams":{"iv":"dfd9ee70812add5f4b8f89d0811c9158"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"0d6769bf016d45c479213990d6a08d938469c4adad8a02ce507b4a4e7b7739f1"},"mac":"bac9af994b15a45dd39669fc66f9aa8a3b9dd8c22cb16e4d8d7ea089d0f1a1a9"},"id":"472e8b3d-afb6-45b5-8111-72c89895099a","version":3}
\ No newline at end of file
diff --git a/accounts/keystore/testdata/keystore/empty b/accounts/keystore/testdata/keystore/empty
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/accounts/keystore/testdata/keystore/foo/fd9bd350f08ee3c0c19b85a8e16114a11a60aa4e b/accounts/keystore/testdata/keystore/foo/fd9bd350f08ee3c0c19b85a8e16114a11a60aa4e
deleted file mode 100644
index 309841e524..0000000000
--- a/accounts/keystore/testdata/keystore/foo/fd9bd350f08ee3c0c19b85a8e16114a11a60aa4e
+++ /dev/null
@@ -1 +0,0 @@
-{"address":"fd9bd350f08ee3c0c19b85a8e16114a11a60aa4e","crypto":{"cipher":"aes-128-ctr","ciphertext":"8124d5134aa4a927c79fd852989e4b5419397566f04b0936a1eb1d168c7c68a5","cipherparams":{"iv":"e2febe17176414dd2cda28287947eb2f"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":4096,"p":6,"r":8,"salt":"44b415ede89f3bdd6830390a21b78965f571b347a589d1d943029f016c5e8bd5"},"mac":"5e149ff25bfd9dd45746a84bb2bcd2f015f2cbca2b6d25c5de8c29617f71fe5b"},"id":"d6ac5452-2b2c-4d3c-ad80-4bf0327d971c","version":3}
\ No newline at end of file
diff --git a/accounts/keystore/testdata/keystore/garbage b/accounts/keystore/testdata/keystore/garbage
deleted file mode 100644
index ff45091e71..0000000000
Binary files a/accounts/keystore/testdata/keystore/garbage and /dev/null differ
diff --git a/accounts/keystore/testdata/keystore/no-address b/accounts/keystore/testdata/keystore/no-address
deleted file mode 100644
index ad51269ead..0000000000
--- a/accounts/keystore/testdata/keystore/no-address
+++ /dev/null
@@ -1 +0,0 @@
-{"crypto":{"cipher":"aes-128-ctr","ciphertext":"cb664472deacb41a2e995fa7f96fe29ce744471deb8d146a0e43c7898c9ddd4d","cipherparams":{"iv":"dfd9ee70812add5f4b8f89d0811c9158"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"0d6769bf016d45c479213990d6a08d938469c4adad8a02ce507b4a4e7b7739f1"},"mac":"bac9af994b15a45dd39669fc66f9aa8a3b9dd8c22cb16e4d8d7ea089d0f1a1a9"},"id":"472e8b3d-afb6-45b5-8111-72c89895099a","version":3}
\ No newline at end of file
diff --git a/accounts/keystore/testdata/keystore/zero b/accounts/keystore/testdata/keystore/zero
deleted file mode 100644
index b52617f8ae..0000000000
--- a/accounts/keystore/testdata/keystore/zero
+++ /dev/null
@@ -1 +0,0 @@
-{"address":"0000000000000000000000000000000000000000","crypto":{"cipher":"aes-128-ctr","ciphertext":"cb664472deacb41a2e995fa7f96fe29ce744471deb8d146a0e43c7898c9ddd4d","cipherparams":{"iv":"dfd9ee70812add5f4b8f89d0811c9158"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"0d6769bf016d45c479213990d6a08d938469c4adad8a02ce507b4a4e7b7739f1"},"mac":"bac9af994b15a45dd39669fc66f9aa8a3b9dd8c22cb16e4d8d7ea089d0f1a1a9"},"id":"472e8b3d-afb6-45b5-8111-72c89895099a","version":3}
\ No newline at end of file
diff --git a/accounts/keystore/testdata/keystore/zzz b/accounts/keystore/testdata/keystore/zzz
deleted file mode 100644
index cfd8a47017..0000000000
--- a/accounts/keystore/testdata/keystore/zzz
+++ /dev/null
@@ -1 +0,0 @@
-{"address":"289d485d9771714cce91d3393d764e1311907acc","crypto":{"cipher":"aes-128-ctr","ciphertext":"faf32ca89d286b107f5e6d842802e05263c49b78d46eac74e6109e9a963378ab","cipherparams":{"iv":"558833eec4a665a8c55608d7d503407d"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"d571fff447ffb24314f9513f5160246f09997b857ac71348b73e785aab40dc04"},"mac":"21edb85ff7d0dab1767b9bf498f2c3cb7be7609490756bd32300bb213b59effe"},"id":"3279afcf-55ba-43ff-8997-02dcc46a6525","version":3}
\ No newline at end of file
diff --git a/accounts/keystore/testdata/v1/cb61d5a9c4896fb9658090b597ef0e7be6f7b67e/cb61d5a9c4896fb9658090b597ef0e7be6f7b67e b/accounts/keystore/testdata/v1/cb61d5a9c4896fb9658090b597ef0e7be6f7b67e/cb61d5a9c4896fb9658090b597ef0e7be6f7b67e
deleted file mode 100644
index 498d8131e8..0000000000
--- a/accounts/keystore/testdata/v1/cb61d5a9c4896fb9658090b597ef0e7be6f7b67e/cb61d5a9c4896fb9658090b597ef0e7be6f7b67e
+++ /dev/null
@@ -1 +0,0 @@
-{"address":"cb61d5a9c4896fb9658090b597ef0e7be6f7b67e","Crypto":{"cipher":"aes-128-cbc","ciphertext":"6143d3192db8b66eabd693d9c4e414dcfaee52abda451af79ccf474dafb35f1bfc7ea013aa9d2ee35969a1a2e8d752d0","cipherparams":{"iv":"35337770fc2117994ecdcad026bccff4"},"kdf":"scrypt","kdfparams":{"n":262144,"r":8,"p":1,"dklen":32,"salt":"9afcddebca541253a2f4053391c673ff9fe23097cd8555d149d929e4ccf1257f"},"mac":"3f3d5af884b17a100b0b3232c0636c230a54dc2ac8d986227219b0dd89197644","version":"1"},"id":"e25f7c1f-d318-4f29-b62c-687190d4d299","version":"1"}
\ No newline at end of file
diff --git a/accounts/keystore/testdata/v1_test_vector.json b/accounts/keystore/testdata/v1_test_vector.json
deleted file mode 100644
index 3d09b55b5e..0000000000
--- a/accounts/keystore/testdata/v1_test_vector.json
+++ /dev/null
@@ -1,28 +0,0 @@
-{
- "test1": {
- "json": {
- "Crypto": {
- "cipher": "aes-128-cbc",
- "cipherparams": {
- "iv": "35337770fc2117994ecdcad026bccff4"
- },
- "ciphertext": "6143d3192db8b66eabd693d9c4e414dcfaee52abda451af79ccf474dafb35f1bfc7ea013aa9d2ee35969a1a2e8d752d0",
- "kdf": "scrypt",
- "kdfparams": {
- "dklen": 32,
- "n": 262144,
- "p": 1,
- "r": 8,
- "salt": "9afcddebca541253a2f4053391c673ff9fe23097cd8555d149d929e4ccf1257f"
- },
- "mac": "3f3d5af884b17a100b0b3232c0636c230a54dc2ac8d986227219b0dd89197644",
- "version": "1"
- },
- "address": "cb61d5a9c4896fb9658090b597ef0e7be6f7b67e",
- "id": "e25f7c1f-d318-4f29-b62c-687190d4d299",
- "version": "1"
- },
- "password": "g",
- "priv": "d1b1178d3529626a1a93e073f65028370d14c7eb0936eb42abef05db6f37ad7d"
- }
-}
diff --git a/accounts/keystore/testdata/v3_test_vector.json b/accounts/keystore/testdata/v3_test_vector.json
deleted file mode 100644
index 1e7f790c05..0000000000
--- a/accounts/keystore/testdata/v3_test_vector.json
+++ /dev/null
@@ -1,97 +0,0 @@
-{
- "wikipage_test_vector_scrypt": {
- "json": {
- "crypto" : {
- "cipher" : "aes-128-ctr",
- "cipherparams" : {
- "iv" : "83dbcc02d8ccb40e466191a123791e0e"
- },
- "ciphertext" : "d172bf743a674da9cdad04534d56926ef8358534d458fffccd4e6ad2fbde479c",
- "kdf" : "scrypt",
- "kdfparams" : {
- "dklen" : 32,
- "n" : 262144,
- "r" : 1,
- "p" : 8,
- "salt" : "ab0c7876052600dd703518d6fc3fe8984592145b591fc8fb5c6d43190334ba19"
- },
- "mac" : "2103ac29920d71da29f15d75b4a16dbe95cfd7ff8faea1056c33131d846e3097"
- },
- "id" : "3198bc9c-6672-5ab3-d995-4942343ae5b6",
- "version" : 3
- },
- "password": "testpassword",
- "priv": "7a28b5ba57c53603b0b07b56bba752f7784bf506fa95edc395f5cf6c7514fe9d"
- },
- "wikipage_test_vector_pbkdf2": {
- "json": {
- "crypto" : {
- "cipher" : "aes-128-ctr",
- "cipherparams" : {
- "iv" : "6087dab2f9fdbbfaddc31a909735c1e6"
- },
- "ciphertext" : "5318b4d5bcd28de64ee5559e671353e16f075ecae9f99c7a79a38af5f869aa46",
- "kdf" : "pbkdf2",
- "kdfparams" : {
- "c" : 262144,
- "dklen" : 32,
- "prf" : "hmac-sha256",
- "salt" : "ae3cd4e7013836a3df6bd7241b12db061dbe2c6785853cce422d148a624ce0bd"
- },
- "mac" : "517ead924a9d0dc3124507e3393d175ce3ff7c1e96529c6c555ce9e51205e9b2"
- },
- "id" : "3198bc9c-6672-5ab3-d995-4942343ae5b6",
- "version" : 3
- },
- "password": "testpassword",
- "priv": "7a28b5ba57c53603b0b07b56bba752f7784bf506fa95edc395f5cf6c7514fe9d"
- },
- "31_byte_key": {
- "json": {
- "crypto" : {
- "cipher" : "aes-128-ctr",
- "cipherparams" : {
- "iv" : "e0c41130a323adc1446fc82f724bca2f"
- },
- "ciphertext" : "9517cd5bdbe69076f9bf5057248c6c050141e970efa36ce53692d5d59a3984",
- "kdf" : "scrypt",
- "kdfparams" : {
- "dklen" : 32,
- "n" : 2,
- "r" : 8,
- "p" : 1,
- "salt" : "711f816911c92d649fb4c84b047915679933555030b3552c1212609b38208c63"
- },
- "mac" : "d5e116151c6aa71470e67a7d42c9620c75c4d23229847dcc127794f0732b0db5"
- },
- "id" : "fecfc4ce-e956-48fd-953b-30f8b52ed66c",
- "version" : 3
- },
- "password": "foo",
- "priv": "fa7b3db73dc7dfdf8c5fbdb796d741e4488628c41fc4febd9160a866ba0f35"
- },
- "30_byte_key": {
- "json": {
- "crypto" : {
- "cipher" : "aes-128-ctr",
- "cipherparams" : {
- "iv" : "3ca92af36ad7c2cd92454c59cea5ef00"
- },
- "ciphertext" : "108b7d34f3442fc26ab1ab90ca91476ba6bfa8c00975a49ef9051dc675aa",
- "kdf" : "scrypt",
- "kdfparams" : {
- "dklen" : 32,
- "n" : 2,
- "r" : 8,
- "p" : 1,
- "salt" : "d0769e608fb86cda848065642a9c6fa046845c928175662b8e356c77f914cd3b"
- },
- "mac" : "75d0e6759f7b3cefa319c3be41680ab6beea7d8328653474bd06706d4cc67420"
- },
- "id" : "a37e1559-5955-450d-8075-7b8931b392b2",
- "version" : 3
- },
- "password": "foo",
- "priv": "81c29e8142bb6a81bef5a92bda7a8328a5c85bb2f9542e76f9b0f94fc018"
- }
-}
diff --git a/accounts/keystore/testdata/very-light-scrypt.json b/accounts/keystore/testdata/very-light-scrypt.json
deleted file mode 100644
index d23b9b2b91..0000000000
--- a/accounts/keystore/testdata/very-light-scrypt.json
+++ /dev/null
@@ -1 +0,0 @@
-{"address":"45dea0fb0bba44f4fcf290bba71fd57d7117cbb8","crypto":{"cipher":"aes-128-ctr","ciphertext":"b87781948a1befd247bff51ef4063f716cf6c2d3481163e9a8f42e1f9bb74145","cipherparams":{"iv":"dc4926b48a105133d2f16b96833abf1e"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":2,"p":1,"r":8,"salt":"004244bbdc51cadda545b1cfa43cff9ed2ae88e08c61f1479dbb45410722f8f0"},"mac":"39990c1684557447940d4c69e06b1b82b2aceacb43f284df65c956daf3046b85"},"id":"ce541d8d-c79b-40f8-9f8c-20f59616faba","version":3}
diff --git a/accounts/keystore/wallet.go b/accounts/keystore/wallet.go
deleted file mode 100644
index 1066095f6d..0000000000
--- a/accounts/keystore/wallet.go
+++ /dev/null
@@ -1,150 +0,0 @@
-// 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 keystore
-
-import (
- "math/big"
-
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
-)
-
-// keystoreWallet implements the accounts.Wallet interface for the original
-// keystore.
-type keystoreWallet struct {
- account accounts.Account // Single account contained in this wallet
- keystore *KeyStore // Keystore where the account originates from
-}
-
-// URL implements accounts.Wallet, returning the URL of the account within.
-func (w *keystoreWallet) URL() accounts.URL {
- return w.account.URL
-}
-
-// Status implements accounts.Wallet, returning whether the account held by the
-// keystore wallet is unlocked or not.
-func (w *keystoreWallet) Status() (string, error) {
- w.keystore.mu.RLock()
- defer w.keystore.mu.RUnlock()
-
- if _, ok := w.keystore.unlocked[w.account.Address]; ok {
- return "Unlocked", nil
- }
- return "Locked", nil
-}
-
-// Open implements accounts.Wallet, but is a noop for plain wallets since there
-// is no connection or decryption step necessary to access the list of accounts.
-func (w *keystoreWallet) Open(passphrase string) error { return nil }
-
-// Close implements accounts.Wallet, but is a noop for plain wallets since there
-// is no meaningful open operation.
-func (w *keystoreWallet) Close() error { return nil }
-
-// Accounts implements accounts.Wallet, returning an account list consisting of
-// a single account that the plain keystore wallet contains.
-func (w *keystoreWallet) Accounts() []accounts.Account {
- return []accounts.Account{w.account}
-}
-
-// Contains implements accounts.Wallet, returning whether a particular account is
-// or is not wrapped by this wallet instance.
-func (w *keystoreWallet) Contains(account accounts.Account) bool {
- return account.Address == w.account.Address && (account.URL == (accounts.URL{}) || account.URL == w.account.URL)
-}
-
-// Derive implements accounts.Wallet, but is a noop for plain wallets since there
-// is no notion of hierarchical account derivation for plain keystore accounts.
-func (w *keystoreWallet) Derive(path accounts.DerivationPath, pin bool) (accounts.Account, error) {
- return accounts.Account{}, accounts.ErrNotSupported
-}
-
-// SelfDerive implements accounts.Wallet, but is a noop for plain wallets since
-// there is no notion of hierarchical account derivation for plain keystore accounts.
-func (w *keystoreWallet) SelfDerive(bases []accounts.DerivationPath, chain ethereum.ChainStateReader) {
-}
-
-// signHash attempts to sign the given hash with
-// the given account. If the wallet does not wrap this particular account, an
-// error is returned to avoid account leakage (even though in theory we may be
-// able to sign via our shared keystore backend).
-func (w *keystoreWallet) signHash(account accounts.Account, hash []byte) ([]byte, error) {
- // Make sure the requested account is contained within
- if !w.Contains(account) {
- return nil, accounts.ErrUnknownAccount
- }
- // Account seems valid, request the keystore to sign
- return w.keystore.SignHash(account, hash)
-}
-
-// SignData signs keccak256(data). The mimetype parameter describes the type of data being signed.
-func (w *keystoreWallet) SignData(account accounts.Account, mimeType string, data []byte) ([]byte, error) {
- return w.signHash(account, crypto.Keccak256(data))
-}
-
-// SignDataWithPassphrase signs keccak256(data). The mimetype parameter describes the type of data being signed.
-func (w *keystoreWallet) SignDataWithPassphrase(account accounts.Account, passphrase, mimeType string, data []byte) ([]byte, error) {
- // Make sure the requested account is contained within
- if !w.Contains(account) {
- return nil, accounts.ErrUnknownAccount
- }
- // Account seems valid, request the keystore to sign
- return w.keystore.SignHashWithPassphrase(account, passphrase, crypto.Keccak256(data))
-}
-
-// SignText implements accounts.Wallet, attempting to sign the hash of
-// the given text with the given account.
-func (w *keystoreWallet) SignText(account accounts.Account, text []byte) ([]byte, error) {
- return w.signHash(account, accounts.TextHash(text))
-}
-
-// SignTextWithPassphrase implements accounts.Wallet, attempting to sign the
-// hash of the given text with the given account using passphrase as extra authentication.
-func (w *keystoreWallet) SignTextWithPassphrase(account accounts.Account, passphrase string, text []byte) ([]byte, error) {
- // Make sure the requested account is contained within
- if !w.Contains(account) {
- return nil, accounts.ErrUnknownAccount
- }
- // Account seems valid, request the keystore to sign
- return w.keystore.SignHashWithPassphrase(account, passphrase, accounts.TextHash(text))
-}
-
-// SignTx implements accounts.Wallet, attempting to sign the given transaction
-// with the given account. If the wallet does not wrap this particular account,
-// an error is returned to avoid account leakage (even though in theory we may
-// be able to sign via our shared keystore backend).
-func (w *keystoreWallet) SignTx(account accounts.Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
- // Make sure the requested account is contained within
- if !w.Contains(account) {
- return nil, accounts.ErrUnknownAccount
- }
- // Account seems valid, request the keystore to sign
- return w.keystore.SignTx(account, tx, chainID)
-}
-
-// SignTxWithPassphrase implements accounts.Wallet, attempting to sign the given
-// transaction with the given account using passphrase as extra authentication.
-func (w *keystoreWallet) SignTxWithPassphrase(account accounts.Account, passphrase string, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
- // Make sure the requested account is contained within
- if !w.Contains(account) {
- return nil, accounts.ErrUnknownAccount
- }
- // Account seems valid, request the keystore to sign
- return w.keystore.SignTxWithPassphrase(account, passphrase, tx, chainID)
-}
diff --git a/accounts/keystore/watch.go b/accounts/keystore/watch.go
deleted file mode 100644
index 1bef321cd1..0000000000
--- a/accounts/keystore/watch.go
+++ /dev/null
@@ -1,134 +0,0 @@
-// 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 .
-
-//go:build (darwin && !ios && cgo) || freebsd || (linux && !arm64) || netbsd || solaris
-// +build darwin,!ios,cgo freebsd linux,!arm64 netbsd solaris
-
-package keystore
-
-import (
- "os"
- "time"
-
- "github.com/ethereum/go-ethereum/log"
- "github.com/fsnotify/fsnotify"
-)
-
-type watcher struct {
- ac *accountCache
- running bool // set to true when runloop begins
- runEnded bool // set to true when runloop ends
- starting bool // set to true prior to runloop starting
- quit chan struct{}
-}
-
-func newWatcher(ac *accountCache) *watcher {
- return &watcher{
- ac: ac,
- quit: make(chan struct{}),
- }
-}
-
-// enabled returns false on systems not supported.
-func (*watcher) enabled() bool { return true }
-
-// starts the watcher loop in the background.
-// Start a watcher in the background if that's not already in progress.
-// The caller must hold w.ac.mu.
-func (w *watcher) start() {
- if w.starting || w.running {
- return
- }
- w.starting = true
- go w.loop()
-}
-
-func (w *watcher) close() {
- close(w.quit)
-}
-
-func (w *watcher) loop() {
- defer func() {
- w.ac.mu.Lock()
- w.running = false
- w.starting = false
- w.runEnded = true
- w.ac.mu.Unlock()
- }()
- logger := log.New("path", w.ac.keydir)
-
- // Create new watcher.
- watcher, err := fsnotify.NewWatcher()
- if err != nil {
- log.Error("Failed to start filesystem watcher", "err", err)
- return
- }
- defer watcher.Close()
- if err := watcher.Add(w.ac.keydir); err != nil {
- if !os.IsNotExist(err) {
- logger.Warn("Failed to watch keystore folder", "err", err)
- }
- return
- }
-
- logger.Trace("Started watching keystore folder", "folder", w.ac.keydir)
- defer logger.Trace("Stopped watching keystore folder")
-
- w.ac.mu.Lock()
- w.running = true
- w.ac.mu.Unlock()
-
- // Wait for file system events and reload.
- // When an event occurs, the reload call is delayed a bit so that
- // multiple events arriving quickly only cause a single reload.
- var (
- debounceDuration = 500 * time.Millisecond
- rescanTriggered = false
- debounce = time.NewTimer(0)
- )
- // Ignore initial trigger
- if !debounce.Stop() {
- <-debounce.C
- }
- defer debounce.Stop()
- for {
- select {
- case <-w.quit:
- return
- case _, ok := <-watcher.Events:
- if !ok {
- return
- }
- // Trigger the scan (with delay), if not already triggered
- if !rescanTriggered {
- debounce.Reset(debounceDuration)
- rescanTriggered = true
- }
- // The fsnotify library does provide more granular event-info, it
- // would be possible to refresh individual affected files instead
- // of scheduling a full rescan. For most cases though, the
- // full rescan is quick and obviously simplest.
- case err, ok := <-watcher.Errors:
- if !ok {
- return
- }
- log.Info("Filesystem watcher error", "err", err)
- case <-debounce.C:
- w.ac.scanAccounts()
- rescanTriggered = false
- }
- }
-}
diff --git a/accounts/keystore/watch_fallback.go b/accounts/keystore/watch_fallback.go
deleted file mode 100644
index e3c133b3f6..0000000000
--- a/accounts/keystore/watch_fallback.go
+++ /dev/null
@@ -1,35 +0,0 @@
-// 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 .
-
-//go:build (darwin && !cgo) || ios || (linux && arm64) || windows || (!darwin && !freebsd && !linux && !netbsd && !solaris)
-// +build darwin,!cgo ios linux,arm64 windows !darwin,!freebsd,!linux,!netbsd,!solaris
-
-// This is the fallback implementation of directory watching.
-// It is used on unsupported platforms.
-
-package keystore
-
-type watcher struct {
- running bool
- runEnded bool
-}
-
-func newWatcher(*accountCache) *watcher { return new(watcher) }
-func (*watcher) start() {}
-func (*watcher) close() {}
-
-// enabled returns false on systems not supported.
-func (*watcher) enabled() bool { return false }
diff --git a/accounts/manager.go b/accounts/manager.go
deleted file mode 100644
index cbe4f7c79d..0000000000
--- a/accounts/manager.go
+++ /dev/null
@@ -1,275 +0,0 @@
-// 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 accounts
-
-import (
- "reflect"
- "sort"
- "sync"
-
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/event"
-)
-
-// managerSubBufferSize determines how many incoming wallet events
-// the manager will buffer in its channel.
-const managerSubBufferSize = 50
-
-// Config contains the settings of the global account manager.
-//
-// TODO(rjl493456442, karalabe, holiman): Get rid of this when account management
-// is removed in favor of Clef.
-type Config struct {
- InsecureUnlockAllowed bool // Whether account unlocking in insecure environment is allowed
-}
-
-// newBackendEvent lets the manager know it should
-// track the given backend for wallet updates.
-type newBackendEvent struct {
- backend Backend
- processed chan struct{} // Informs event emitter that backend has been integrated
-}
-
-// Manager is an overarching account manager that can communicate with various
-// backends for signing transactions.
-type Manager struct {
- config *Config // Global account manager configurations
- backends map[reflect.Type][]Backend // Index of backends currently registered
- updaters []event.Subscription // Wallet update subscriptions for all backends
- updates chan WalletEvent // Subscription sink for backend wallet changes
- newBackends chan newBackendEvent // Incoming backends to be tracked by the manager
- wallets []Wallet // Cache of all wallets from all registered backends
-
- feed event.Feed // Wallet feed notifying of arrivals/departures
-
- quit chan chan error
- term chan struct{} // Channel is closed upon termination of the update loop
- lock sync.RWMutex
-}
-
-// NewManager creates a generic account manager to sign transaction via various
-// supported backends.
-func NewManager(config *Config, backends ...Backend) *Manager {
- // Retrieve the initial list of wallets from the backends and sort by URL
- var wallets []Wallet
- for _, backend := range backends {
- wallets = merge(wallets, backend.Wallets()...)
- }
- // Subscribe to wallet notifications from all backends
- updates := make(chan WalletEvent, managerSubBufferSize)
-
- subs := make([]event.Subscription, len(backends))
- for i, backend := range backends {
- subs[i] = backend.Subscribe(updates)
- }
- // Assemble the account manager and return
- am := &Manager{
- config: config,
- backends: make(map[reflect.Type][]Backend),
- updaters: subs,
- updates: updates,
- newBackends: make(chan newBackendEvent),
- wallets: wallets,
- quit: make(chan chan error),
- term: make(chan struct{}),
- }
- for _, backend := range backends {
- kind := reflect.TypeOf(backend)
- am.backends[kind] = append(am.backends[kind], backend)
- }
- go am.update()
-
- return am
-}
-
-// Close terminates the account manager's internal notification processes.
-func (am *Manager) Close() error {
- for _, w := range am.wallets {
- w.Close()
- }
- errc := make(chan error)
- am.quit <- errc
- return <-errc
-}
-
-// Config returns the configuration of account manager.
-func (am *Manager) Config() *Config {
- return am.config
-}
-
-// AddBackend starts the tracking of an additional backend for wallet updates.
-// cmd/geth assumes once this func returns the backends have been already integrated.
-func (am *Manager) AddBackend(backend Backend) {
- done := make(chan struct{})
- am.newBackends <- newBackendEvent{backend, done}
- <-done
-}
-
-// update is the wallet event loop listening for notifications from the backends
-// and updating the cache of wallets.
-func (am *Manager) update() {
- // Close all subscriptions when the manager terminates
- defer func() {
- am.lock.Lock()
- for _, sub := range am.updaters {
- sub.Unsubscribe()
- }
- am.updaters = nil
- am.lock.Unlock()
- }()
-
- // Loop until termination
- for {
- select {
- case event := <-am.updates:
- // Wallet event arrived, update local cache
- am.lock.Lock()
- switch event.Kind {
- case WalletArrived:
- am.wallets = merge(am.wallets, event.Wallet)
- case WalletDropped:
- am.wallets = drop(am.wallets, event.Wallet)
- }
- am.lock.Unlock()
-
- // Notify any listeners of the event
- am.feed.Send(event)
- case event := <-am.newBackends:
- am.lock.Lock()
- // Update caches
- backend := event.backend
- am.wallets = merge(am.wallets, backend.Wallets()...)
- am.updaters = append(am.updaters, backend.Subscribe(am.updates))
- kind := reflect.TypeOf(backend)
- am.backends[kind] = append(am.backends[kind], backend)
- am.lock.Unlock()
- close(event.processed)
- case errc := <-am.quit:
- // Manager terminating, return
- errc <- nil
- // Signals event emitters the loop is not receiving values
- // to prevent them from getting stuck.
- close(am.term)
- return
- }
- }
-}
-
-// Backends retrieves the backend(s) with the given type from the account manager.
-func (am *Manager) Backends(kind reflect.Type) []Backend {
- am.lock.RLock()
- defer am.lock.RUnlock()
-
- return am.backends[kind]
-}
-
-// Wallets returns all signer accounts registered under this account manager.
-func (am *Manager) Wallets() []Wallet {
- am.lock.RLock()
- defer am.lock.RUnlock()
-
- return am.walletsNoLock()
-}
-
-// walletsNoLock returns all registered wallets. Callers must hold am.lock.
-func (am *Manager) walletsNoLock() []Wallet {
- cpy := make([]Wallet, len(am.wallets))
- copy(cpy, am.wallets)
- return cpy
-}
-
-// Wallet retrieves the wallet associated with a particular URL.
-func (am *Manager) Wallet(url string) (Wallet, error) {
- am.lock.RLock()
- defer am.lock.RUnlock()
-
- parsed, err := parseURL(url)
- if err != nil {
- return nil, err
- }
- for _, wallet := range am.walletsNoLock() {
- if wallet.URL() == parsed {
- return wallet, nil
- }
- }
- return nil, ErrUnknownWallet
-}
-
-// Accounts returns all account addresses of all wallets within the account manager
-func (am *Manager) Accounts() []common.Address {
- am.lock.RLock()
- defer am.lock.RUnlock()
-
- addresses := make([]common.Address, 0) // return [] instead of nil if empty
- for _, wallet := range am.wallets {
- for _, account := range wallet.Accounts() {
- addresses = append(addresses, account.Address)
- }
- }
- return addresses
-}
-
-// Find attempts to locate the wallet corresponding to a specific account. Since
-// accounts can be dynamically added to and removed from wallets, this method has
-// a linear runtime in the number of wallets.
-func (am *Manager) Find(account Account) (Wallet, error) {
- am.lock.RLock()
- defer am.lock.RUnlock()
-
- for _, wallet := range am.wallets {
- if wallet.Contains(account) {
- return wallet, nil
- }
- }
- return nil, ErrUnknownAccount
-}
-
-// Subscribe creates an async subscription to receive notifications when the
-// manager detects the arrival or departure of a wallet from any of its backends.
-func (am *Manager) Subscribe(sink chan<- WalletEvent) event.Subscription {
- return am.feed.Subscribe(sink)
-}
-
-// merge is a sorted analogue of append for wallets, where the ordering of the
-// origin list is preserved by inserting new wallets at the correct position.
-//
-// The original slice is assumed to be already sorted by URL.
-func merge(slice []Wallet, wallets ...Wallet) []Wallet {
- for _, wallet := range wallets {
- n := sort.Search(len(slice), func(i int) bool { return slice[i].URL().Cmp(wallet.URL()) >= 0 })
- if n == len(slice) {
- slice = append(slice, wallet)
- continue
- }
- slice = append(slice[:n], append([]Wallet{wallet}, slice[n:]...)...)
- }
- return slice
-}
-
-// drop is the counterpart of merge, which looks up wallets from within the sorted
-// cache and removes the ones specified.
-func drop(slice []Wallet, wallets ...Wallet) []Wallet {
- for _, wallet := range wallets {
- n := sort.Search(len(slice), func(i int) bool { return slice[i].URL().Cmp(wallet.URL()) >= 0 })
- if n == len(slice) {
- // Wallet not found, may happen during startup
- continue
- }
- slice = append(slice[:n], slice[n+1:]...)
- }
- return slice
-}
diff --git a/accounts/scwallet/README.md b/accounts/scwallet/README.md
deleted file mode 100644
index 28079c4743..0000000000
--- a/accounts/scwallet/README.md
+++ /dev/null
@@ -1,106 +0,0 @@
-# Using the smartcard wallet
-
-## Requirements
-
- * A USB smartcard reader
- * A keycard that supports the status app
- * PCSCD version 4.3 running on your system **Only version 4.3 is currently supported**
-
-## Preparing the smartcard
-
- **WARNING: FOLLOWING THESE INSTRUCTIONS WILL DESTROY THE MASTER KEY ON YOUR CARD. ONLY PROCEED IF NO FUNDS ARE ASSOCIATED WITH THESE ACCOUNTS**
-
- You can use status' [keycard-cli](https://github.com/status-im/keycard-cli) and you should get _at least_ version 2.1.1 of their [smartcard application](https://github.com/status-im/status-keycard/releases/download/2.2.1/keycard_v2.2.1.cap)
-
- You also need to make sure that the PCSC daemon is running on your system.
-
- Then, you can install the application to the card by typing:
-
- ```
- keycard install -a keycard_v2.2.1.cap && keycard init
- ```
-
- At the end of this process, you will be provided with a PIN, a PUK and a pairing password. Write them down, you'll need them shortly.
-
- Start `geth` with the `console` command. You will notice the following warning:
-
- ```
- WARN [04-09|16:58:38.898] Failed to open wallet url=keycard://044def09 err="smartcard: pairing password needed"
- ```
-
- Write down the URL (`keycard://044def09` in this example). Then ask `geth` to open the wallet:
-
- ```
- > personal.openWallet("keycard://044def09", "pairing password")
- ```
-
- The pairing password has been generated during the card initialization process.
-
- The process needs to be repeated once more with the PIN:
-
- ```
- > personal.openWallet("keycard://044def09", "PIN number")
- ```
-
- If everything goes well, you should see your new account when typing `personal` on the console:
-
- ```
- > personal
- WARN [04-09|17:02:07.330] Smartcard wallet account derivation failed url=keycard://044def09 err="Unexpected response status Cla=0x80, Ins=0xd1, Sw=0x6985"
- {
- listAccounts: [],
- listWallets: [{
- status: "Empty, waiting for initialization",
- url: "keycard://044def09"
- }],
- ...
- }
- ```
-
- So the communication with the card is working, but there is no key associated with this wallet. Let's create it:
-
- ```
- > personal.initializeWallet("keycard://044def09")
- "tilt ... impact"
- ```
-
- You should get a list of words, this is your seed so write them down. Your wallet should now be initialized:
-
- ```
- > personal.listWallets
- [{
- accounts: [{
- address: "0x678b7cd55c61917defb23546a41803c5bfefbc7a",
- url: "keycard://044d/m/44'/60'/0'/0/0"
- }],
- status: "Online",
- url: "keycard://044def09"
- }]
- ```
-
- You're all set!
-
-## Usage
-
- 1. Start `geth` with the `console` command
- 2. Check the card's URL by checking `personal.listWallets`:
-
-```
- listWallets: [{
- status: "Online, can derive public keys",
- url: "keycard://a4d73015"
- }]
-```
-
- 3. Open the wallet, you will be prompted for your pairing password, then PIN:
-
-```
-personal.openWallet("keycard://a4d73015")
-```
-
- 4. Check that creation was successful by typing e.g. `personal`. Then use it like a regular wallet.
-
-## Known issues
-
- * Starting geth with a valid card seems to make firefox crash.
- * PCSC version 4.4 should work, but is currently untested
diff --git a/accounts/scwallet/apdu.go b/accounts/scwallet/apdu.go
deleted file mode 100644
index bd3660604e..0000000000
--- a/accounts/scwallet/apdu.go
+++ /dev/null
@@ -1,87 +0,0 @@
-// 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 scwallet
-
-import (
- "bytes"
- "encoding/binary"
- "fmt"
-)
-
-// commandAPDU represents an application data unit sent to a smartcard.
-type commandAPDU struct {
- Cla, Ins, P1, P2 uint8 // Class, Instruction, Parameter 1, Parameter 2
- Data []byte // Command data
- Le uint8 // Command data length
-}
-
-// serialize serializes a command APDU.
-func (ca commandAPDU) serialize() ([]byte, error) {
- buf := new(bytes.Buffer)
-
- if err := binary.Write(buf, binary.BigEndian, ca.Cla); err != nil {
- return nil, err
- }
- if err := binary.Write(buf, binary.BigEndian, ca.Ins); err != nil {
- return nil, err
- }
- if err := binary.Write(buf, binary.BigEndian, ca.P1); err != nil {
- return nil, err
- }
- if err := binary.Write(buf, binary.BigEndian, ca.P2); err != nil {
- return nil, err
- }
- if len(ca.Data) > 0 {
- if err := binary.Write(buf, binary.BigEndian, uint8(len(ca.Data))); err != nil {
- return nil, err
- }
- if err := binary.Write(buf, binary.BigEndian, ca.Data); err != nil {
- return nil, err
- }
- }
- if err := binary.Write(buf, binary.BigEndian, ca.Le); err != nil {
- return nil, err
- }
- return buf.Bytes(), nil
-}
-
-// responseAPDU represents an application data unit received from a smart card.
-type responseAPDU struct {
- Data []byte // response data
- Sw1, Sw2 uint8 // status words 1 and 2
-}
-
-// deserialize deserializes a response APDU.
-func (ra *responseAPDU) deserialize(data []byte) error {
- if len(data) < 2 {
- return fmt.Errorf("can not deserialize data: payload too short (%d < 2)", len(data))
- }
-
- ra.Data = make([]byte, len(data)-2)
-
- buf := bytes.NewReader(data)
- if err := binary.Read(buf, binary.BigEndian, &ra.Data); err != nil {
- return err
- }
- if err := binary.Read(buf, binary.BigEndian, &ra.Sw1); err != nil {
- return err
- }
- if err := binary.Read(buf, binary.BigEndian, &ra.Sw2); err != nil {
- return err
- }
- return nil
-}
diff --git a/accounts/scwallet/hub.go b/accounts/scwallet/hub.go
deleted file mode 100644
index f9dcf58e19..0000000000
--- a/accounts/scwallet/hub.go
+++ /dev/null
@@ -1,302 +0,0 @@
-// 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 .
-
-// This package implements support for smartcard-based hardware wallets such as
-// the one written by Status: https://github.com/status-im/hardware-wallet
-//
-// This implementation of smartcard wallets have a different interaction process
-// to other types of hardware wallet. The process works like this:
-//
-// 1. (First use with a given client) Establish a pairing between hardware
-// wallet and client. This requires a secret value called a 'pairing password'.
-// You can pair with an unpaired wallet with `personal.openWallet(URI, pairing password)`.
-// 2. (First use only) Initialize the wallet, which generates a keypair, stores
-// it on the wallet, and returns it so the user can back it up. You can
-// initialize a wallet with `personal.initializeWallet(URI)`.
-// 3. Connect to the wallet using the pairing information established in step 1.
-// You can connect to a paired wallet with `personal.openWallet(URI, PIN)`.
-// 4. Interact with the wallet as normal.
-
-package scwallet
-
-import (
- "encoding/json"
- "io"
- "os"
- "path/filepath"
- "sort"
- "sync"
- "time"
-
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/log"
- pcsc "github.com/gballet/go-libpcsclite"
-)
-
-// Scheme is the URI prefix for smartcard wallets.
-const Scheme = "keycard"
-
-// refreshCycle is the maximum time between wallet refreshes (if USB hotplug
-// notifications don't work).
-const refreshCycle = time.Second
-
-// refreshThrottling is the minimum time between wallet refreshes to avoid thrashing.
-const refreshThrottling = 500 * time.Millisecond
-
-// smartcardPairing contains information about a smart card we have paired with
-// or might pair with the hub.
-type smartcardPairing struct {
- PublicKey []byte `json:"publicKey"`
- PairingIndex uint8 `json:"pairingIndex"`
- PairingKey []byte `json:"pairingKey"`
- Accounts map[common.Address]accounts.DerivationPath `json:"accounts"`
-}
-
-// Hub is a accounts.Backend that can find and handle generic PC/SC hardware wallets.
-type Hub struct {
- scheme string // Protocol scheme prefixing account and wallet URLs.
-
- context *pcsc.Client
- datadir string
- pairings map[string]smartcardPairing
-
- refreshed time.Time // Time instance when the list of wallets was last refreshed
- wallets map[string]*Wallet // Mapping from reader names to wallet instances
- updateFeed event.Feed // Event feed to notify wallet additions/removals
- updateScope event.SubscriptionScope // Subscription scope tracking current live listeners
- updating bool // Whether the event notification loop is running
-
- quit chan chan error
-
- stateLock sync.RWMutex // Protects the internals of the hub from racey access
-}
-
-func (hub *Hub) readPairings() error {
- hub.pairings = make(map[string]smartcardPairing)
- pairingFile, err := os.Open(filepath.Join(hub.datadir, "smartcards.json"))
- if err != nil {
- if os.IsNotExist(err) {
- return nil
- }
- return err
- }
-
- pairingData, err := io.ReadAll(pairingFile)
- if err != nil {
- return err
- }
- var pairings []smartcardPairing
- if err := json.Unmarshal(pairingData, &pairings); err != nil {
- return err
- }
-
- for _, pairing := range pairings {
- hub.pairings[string(pairing.PublicKey)] = pairing
- }
- return nil
-}
-
-func (hub *Hub) writePairings() error {
- pairingFile, err := os.OpenFile(filepath.Join(hub.datadir, "smartcards.json"), os.O_RDWR|os.O_CREATE, 0755)
- if err != nil {
- return err
- }
- defer pairingFile.Close()
-
- pairings := make([]smartcardPairing, 0, len(hub.pairings))
- for _, pairing := range hub.pairings {
- pairings = append(pairings, pairing)
- }
-
- pairingData, err := json.Marshal(pairings)
- if err != nil {
- return err
- }
-
- if _, err := pairingFile.Write(pairingData); err != nil {
- return err
- }
-
- return nil
-}
-
-func (hub *Hub) pairing(wallet *Wallet) *smartcardPairing {
- if pairing, ok := hub.pairings[string(wallet.PublicKey)]; ok {
- return &pairing
- }
- return nil
-}
-
-func (hub *Hub) setPairing(wallet *Wallet, pairing *smartcardPairing) error {
- if pairing == nil {
- delete(hub.pairings, string(wallet.PublicKey))
- } else {
- hub.pairings[string(wallet.PublicKey)] = *pairing
- }
- return hub.writePairings()
-}
-
-// NewHub creates a new hardware wallet manager for smartcards.
-func NewHub(daemonPath string, scheme string, datadir string) (*Hub, error) {
- context, err := pcsc.EstablishContext(daemonPath, pcsc.ScopeSystem)
- if err != nil {
- return nil, err
- }
- hub := &Hub{
- scheme: scheme,
- context: context,
- datadir: datadir,
- wallets: make(map[string]*Wallet),
- quit: make(chan chan error),
- }
- if err := hub.readPairings(); err != nil {
- return nil, err
- }
- hub.refreshWallets()
- return hub, nil
-}
-
-// Wallets implements accounts.Backend, returning all the currently tracked smart
-// cards that appear to be hardware wallets.
-func (hub *Hub) Wallets() []accounts.Wallet {
- // Make sure the list of wallets is up to date
- hub.refreshWallets()
-
- hub.stateLock.RLock()
- defer hub.stateLock.RUnlock()
-
- cpy := make([]accounts.Wallet, 0, len(hub.wallets))
- for _, wallet := range hub.wallets {
- cpy = append(cpy, wallet)
- }
- sort.Sort(accounts.WalletsByURL(cpy))
- return cpy
-}
-
-// refreshWallets scans the devices attached to the machine and updates the
-// list of wallets based on the found devices.
-func (hub *Hub) refreshWallets() {
- // Don't scan the USB like crazy it the user fetches wallets in a loop
- hub.stateLock.RLock()
- elapsed := time.Since(hub.refreshed)
- hub.stateLock.RUnlock()
-
- if elapsed < refreshThrottling {
- return
- }
- // Retrieve all the smart card reader to check for cards
- readers, err := hub.context.ListReaders()
- if err != nil {
- // This is a perverted hack, the scard library returns an error if no card
- // readers are present instead of simply returning an empty list. We don't
- // want to fill the user's log with errors, so filter those out.
- if err.Error() != "scard: Cannot find a smart card reader." {
- log.Error("Failed to enumerate smart card readers", "err", err)
- return
- }
- }
- // Transform the current list of wallets into the new one
- hub.stateLock.Lock()
-
- events := []accounts.WalletEvent{}
- seen := make(map[string]struct{})
-
- for _, reader := range readers {
- // Mark the reader as present
- seen[reader] = struct{}{}
-
- // If we already know about this card, skip to the next reader, otherwise clean up
- if wallet, ok := hub.wallets[reader]; ok {
- if err := wallet.ping(); err == nil {
- continue
- }
- wallet.Close()
- events = append(events, accounts.WalletEvent{Wallet: wallet, Kind: accounts.WalletDropped})
- delete(hub.wallets, reader)
- }
- // New card detected, try to connect to it
- card, err := hub.context.Connect(reader, pcsc.ShareShared, pcsc.ProtocolAny)
- if err != nil {
- log.Debug("Failed to open smart card", "reader", reader, "err", err)
- continue
- }
- wallet := NewWallet(hub, card)
- if err = wallet.connect(); err != nil {
- log.Debug("Failed to connect to smart card", "reader", reader, "err", err)
- card.Disconnect(pcsc.LeaveCard)
- continue
- }
- // Card connected, start tracking in amongs the wallets
- hub.wallets[reader] = wallet
- events = append(events, accounts.WalletEvent{Wallet: wallet, Kind: accounts.WalletArrived})
- }
- // Remove any wallets no longer present
- for reader, wallet := range hub.wallets {
- if _, ok := seen[reader]; !ok {
- wallet.Close()
- events = append(events, accounts.WalletEvent{Wallet: wallet, Kind: accounts.WalletDropped})
- delete(hub.wallets, reader)
- }
- }
- hub.refreshed = time.Now()
- hub.stateLock.Unlock()
-
- for _, event := range events {
- hub.updateFeed.Send(event)
- }
-}
-
-// Subscribe implements accounts.Backend, creating an async subscription to
-// receive notifications on the addition or removal of smart card wallets.
-func (hub *Hub) Subscribe(sink chan<- accounts.WalletEvent) event.Subscription {
- // We need the mutex to reliably start/stop the update loop
- hub.stateLock.Lock()
- defer hub.stateLock.Unlock()
-
- // Subscribe the caller and track the subscriber count
- sub := hub.updateScope.Track(hub.updateFeed.Subscribe(sink))
-
- // Subscribers require an active notification loop, start it
- if !hub.updating {
- hub.updating = true
- go hub.updater()
- }
- return sub
-}
-
-// updater is responsible for maintaining an up-to-date list of wallets managed
-// by the smart card hub, and for firing wallet addition/removal events.
-func (hub *Hub) updater() {
- for {
- // TODO: Wait for a USB hotplug event (not supported yet) or a refresh timeout
- // <-hub.changes
- time.Sleep(refreshCycle)
-
- // Run the wallet refresher
- hub.refreshWallets()
-
- // If all our subscribers left, stop the updater
- hub.stateLock.Lock()
- if hub.updateScope.Count() == 0 {
- hub.updating = false
- hub.stateLock.Unlock()
- return
- }
- hub.stateLock.Unlock()
- }
-}
diff --git a/accounts/scwallet/securechannel.go b/accounts/scwallet/securechannel.go
deleted file mode 100644
index bbd8b22647..0000000000
--- a/accounts/scwallet/securechannel.go
+++ /dev/null
@@ -1,340 +0,0 @@
-// 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 scwallet
-
-import (
- "bytes"
- "crypto/aes"
- "crypto/cipher"
- "crypto/elliptic"
- "crypto/rand"
- "crypto/sha256"
- "crypto/sha512"
- "errors"
- "fmt"
-
- "github.com/ethereum/go-ethereum/crypto"
- pcsc "github.com/gballet/go-libpcsclite"
- "golang.org/x/crypto/pbkdf2"
- "golang.org/x/text/unicode/norm"
-)
-
-const (
- maxPayloadSize = 223
- pairP1FirstStep = 0
- pairP1LastStep = 1
-
- scSecretLength = 32
- scBlockSize = 16
-
- insOpenSecureChannel = 0x10
- insMutuallyAuthenticate = 0x11
- insPair = 0x12
- insUnpair = 0x13
-
- pairingSalt = "Keycard Pairing Password Salt"
-)
-
-// SecureChannelSession enables secure communication with a hardware wallet.
-type SecureChannelSession struct {
- card *pcsc.Card // A handle to the smartcard for communication
- secret []byte // A shared secret generated from our ECDSA keys
- publicKey []byte // Our own ephemeral public key
- PairingKey []byte // A permanent shared secret for a pairing, if present
- sessionEncKey []byte // The current session encryption key
- sessionMacKey []byte // The current session MAC key
- iv []byte // The current IV
- PairingIndex uint8 // The pairing index
-}
-
-// NewSecureChannelSession creates a new secure channel for the given card and public key.
-func NewSecureChannelSession(card *pcsc.Card, keyData []byte) (*SecureChannelSession, error) {
- // Generate an ECDSA keypair for ourselves
- key, err := crypto.GenerateKey()
- if err != nil {
- return nil, err
- }
- cardPublic, err := crypto.UnmarshalPubkey(keyData)
- if err != nil {
- return nil, fmt.Errorf("could not unmarshal public key from card: %v", err)
- }
- secret, _ := key.Curve.ScalarMult(cardPublic.X, cardPublic.Y, key.D.Bytes())
- return &SecureChannelSession{
- card: card,
- secret: secret.Bytes(),
- publicKey: elliptic.Marshal(crypto.S256(), key.PublicKey.X, key.PublicKey.Y),
- }, nil
-}
-
-// Pair establishes a new pairing with the smartcard.
-func (s *SecureChannelSession) Pair(pairingPassword []byte) error {
- secretHash := pbkdf2.Key(norm.NFKD.Bytes(pairingPassword), norm.NFKD.Bytes([]byte(pairingSalt)), 50000, 32, sha256.New)
-
- challenge := make([]byte, 32)
- if _, err := rand.Read(challenge); err != nil {
- return err
- }
-
- response, err := s.pair(pairP1FirstStep, challenge)
- if err != nil {
- return err
- }
-
- md := sha256.New()
- md.Write(secretHash[:])
- md.Write(challenge)
-
- expectedCryptogram := md.Sum(nil)
- cardCryptogram := response.Data[:32]
- cardChallenge := response.Data[32:64]
-
- if !bytes.Equal(expectedCryptogram, cardCryptogram) {
- return fmt.Errorf("invalid card cryptogram %v != %v", expectedCryptogram, cardCryptogram)
- }
-
- md.Reset()
- md.Write(secretHash[:])
- md.Write(cardChallenge)
- response, err = s.pair(pairP1LastStep, md.Sum(nil))
- if err != nil {
- return err
- }
-
- md.Reset()
- md.Write(secretHash[:])
- md.Write(response.Data[1:])
- s.PairingKey = md.Sum(nil)
- s.PairingIndex = response.Data[0]
-
- return nil
-}
-
-// Unpair disestablishes an existing pairing.
-func (s *SecureChannelSession) Unpair() error {
- if s.PairingKey == nil {
- return errors.New("cannot unpair: not paired")
- }
-
- _, err := s.transmitEncrypted(claSCWallet, insUnpair, s.PairingIndex, 0, []byte{})
- if err != nil {
- return err
- }
- s.PairingKey = nil
- // Close channel
- s.iv = nil
- return nil
-}
-
-// Open initializes the secure channel.
-func (s *SecureChannelSession) Open() error {
- if s.iv != nil {
- return errors.New("session already opened")
- }
-
- response, err := s.open()
- if err != nil {
- return err
- }
-
- // Generate the encryption/mac key by hashing our shared secret,
- // pairing key, and the first bytes returned from the Open APDU.
- md := sha512.New()
- md.Write(s.secret)
- md.Write(s.PairingKey)
- md.Write(response.Data[:scSecretLength])
- keyData := md.Sum(nil)
- s.sessionEncKey = keyData[:scSecretLength]
- s.sessionMacKey = keyData[scSecretLength : scSecretLength*2]
-
- // The IV is the last bytes returned from the Open APDU.
- s.iv = response.Data[scSecretLength:]
-
- return s.mutuallyAuthenticate()
-}
-
-// mutuallyAuthenticate is an internal method to authenticate both ends of the
-// connection.
-func (s *SecureChannelSession) mutuallyAuthenticate() error {
- data := make([]byte, scSecretLength)
- if _, err := rand.Read(data); err != nil {
- return err
- }
-
- response, err := s.transmitEncrypted(claSCWallet, insMutuallyAuthenticate, 0, 0, data)
- if err != nil {
- return err
- }
- if response.Sw1 != 0x90 || response.Sw2 != 0x00 {
- return fmt.Errorf("got unexpected response from MUTUALLY_AUTHENTICATE: %#x%x", response.Sw1, response.Sw2)
- }
-
- if len(response.Data) != scSecretLength {
- return fmt.Errorf("response from MUTUALLY_AUTHENTICATE was %d bytes, expected %d", len(response.Data), scSecretLength)
- }
-
- return nil
-}
-
-// open is an internal method that sends an open APDU.
-func (s *SecureChannelSession) open() (*responseAPDU, error) {
- return transmit(s.card, &commandAPDU{
- Cla: claSCWallet,
- Ins: insOpenSecureChannel,
- P1: s.PairingIndex,
- P2: 0,
- Data: s.publicKey,
- Le: 0,
- })
-}
-
-// pair is an internal method that sends a pair APDU.
-func (s *SecureChannelSession) pair(p1 uint8, data []byte) (*responseAPDU, error) {
- return transmit(s.card, &commandAPDU{
- Cla: claSCWallet,
- Ins: insPair,
- P1: p1,
- P2: 0,
- Data: data,
- Le: 0,
- })
-}
-
-// transmitEncrypted sends an encrypted message, and decrypts and returns the response.
-func (s *SecureChannelSession) transmitEncrypted(cla, ins, p1, p2 byte, data []byte) (*responseAPDU, error) {
- if s.iv == nil {
- return nil, errors.New("channel not open")
- }
-
- data, err := s.encryptAPDU(data)
- if err != nil {
- return nil, err
- }
- meta := [16]byte{cla, ins, p1, p2, byte(len(data) + scBlockSize)}
- if err = s.updateIV(meta[:], data); err != nil {
- return nil, err
- }
-
- fulldata := make([]byte, len(s.iv)+len(data))
- copy(fulldata, s.iv)
- copy(fulldata[len(s.iv):], data)
-
- response, err := transmit(s.card, &commandAPDU{
- Cla: cla,
- Ins: ins,
- P1: p1,
- P2: p2,
- Data: fulldata,
- })
- if err != nil {
- return nil, err
- }
-
- rmeta := [16]byte{byte(len(response.Data))}
- rmac := response.Data[:len(s.iv)]
- rdata := response.Data[len(s.iv):]
- plainData, err := s.decryptAPDU(rdata)
- if err != nil {
- return nil, err
- }
-
- if err = s.updateIV(rmeta[:], rdata); err != nil {
- return nil, err
- }
- if !bytes.Equal(s.iv, rmac) {
- return nil, errors.New("invalid MAC in response")
- }
-
- rapdu := &responseAPDU{}
- rapdu.deserialize(plainData)
-
- if rapdu.Sw1 != sw1Ok {
- return nil, fmt.Errorf("unexpected response status Cla=%#x, Ins=%#x, Sw=%#x%x", cla, ins, rapdu.Sw1, rapdu.Sw2)
- }
-
- return rapdu, nil
-}
-
-// encryptAPDU is an internal method that serializes and encrypts an APDU.
-func (s *SecureChannelSession) encryptAPDU(data []byte) ([]byte, error) {
- if len(data) > maxPayloadSize {
- return nil, fmt.Errorf("payload of %d bytes exceeds maximum of %d", len(data), maxPayloadSize)
- }
- data = pad(data, 0x80)
-
- ret := make([]byte, len(data))
-
- a, err := aes.NewCipher(s.sessionEncKey)
- if err != nil {
- return nil, err
- }
- crypter := cipher.NewCBCEncrypter(a, s.iv)
- crypter.CryptBlocks(ret, data)
- return ret, nil
-}
-
-// pad applies message padding to a 16 byte boundary.
-func pad(data []byte, terminator byte) []byte {
- padded := make([]byte, (len(data)/16+1)*16)
- copy(padded, data)
- padded[len(data)] = terminator
- return padded
-}
-
-// decryptAPDU is an internal method that decrypts and deserializes an APDU.
-func (s *SecureChannelSession) decryptAPDU(data []byte) ([]byte, error) {
- a, err := aes.NewCipher(s.sessionEncKey)
- if err != nil {
- return nil, err
- }
-
- ret := make([]byte, len(data))
-
- crypter := cipher.NewCBCDecrypter(a, s.iv)
- crypter.CryptBlocks(ret, data)
- return unpad(ret, 0x80)
-}
-
-// unpad strips padding from a message.
-func unpad(data []byte, terminator byte) ([]byte, error) {
- for i := 1; i <= 16; i++ {
- switch data[len(data)-i] {
- case 0:
- continue
- case terminator:
- return data[:len(data)-i], nil
- default:
- return nil, fmt.Errorf("expected end of padding, got %d", data[len(data)-i])
- }
- }
- return nil, errors.New("expected end of padding, got 0")
-}
-
-// updateIV is an internal method that updates the initialization vector after
-// each message exchanged.
-func (s *SecureChannelSession) updateIV(meta, data []byte) error {
- data = pad(data, 0)
- a, err := aes.NewCipher(s.sessionMacKey)
- if err != nil {
- return err
- }
- crypter := cipher.NewCBCEncrypter(a, make([]byte, 16))
- crypter.CryptBlocks(meta, meta)
- crypter.CryptBlocks(data, data)
- // The first 16 bytes of the last block is the MAC
- s.iv = data[len(data)-32 : len(data)-16]
- return nil
-}
diff --git a/accounts/scwallet/wallet.go b/accounts/scwallet/wallet.go
deleted file mode 100644
index f0ca9085b6..0000000000
--- a/accounts/scwallet/wallet.go
+++ /dev/null
@@ -1,1088 +0,0 @@
-// 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 scwallet
-
-import (
- "bytes"
- "context"
- "crypto/hmac"
- "crypto/sha256"
- "crypto/sha512"
- "encoding/asn1"
- "encoding/binary"
- "errors"
- "fmt"
- "math/big"
- "regexp"
- "sort"
- "strings"
- "sync"
- "time"
-
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/accounts"
- "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"
- pcsc "github.com/gballet/go-libpcsclite"
- "github.com/status-im/keycard-go/derivationpath"
-)
-
-// ErrPairingPasswordNeeded is returned if opening the smart card requires pairing with a pairing
-// password. In this case, the calling application should request user input to enter
-// the pairing password and send it back.
-var ErrPairingPasswordNeeded = errors.New("smartcard: pairing password needed")
-
-// ErrPINNeeded is returned if opening the smart card requires a PIN code. In
-// this case, the calling application should request user input to enter the PIN
-// and send it back.
-var ErrPINNeeded = errors.New("smartcard: pin needed")
-
-// ErrPINUnblockNeeded is returned if opening the smart card requires a PIN code,
-// but all PIN attempts have already been exhausted. In this case the calling
-// application should request user input for the PUK and a new PIN code to set
-// fo the card.
-var ErrPINUnblockNeeded = errors.New("smartcard: pin unblock needed")
-
-// ErrAlreadyOpen is returned if the smart card is attempted to be opened, but
-// there is already a paired and unlocked session.
-var ErrAlreadyOpen = errors.New("smartcard: already open")
-
-// ErrPubkeyMismatch is returned if the public key recovered from a signature
-// does not match the one expected by the user.
-var ErrPubkeyMismatch = errors.New("smartcard: recovered public key mismatch")
-
-var (
- appletAID = []byte{0xA0, 0x00, 0x00, 0x08, 0x04, 0x00, 0x01, 0x01, 0x01}
- // DerivationSignatureHash is used to derive the public key from the signature of this hash
- DerivationSignatureHash = sha256.Sum256(common.Hash{}.Bytes())
-)
-
-// List of APDU command-related constants
-const (
- claISO7816 = 0
- claSCWallet = 0x80
-
- insSelect = 0xA4
- insGetResponse = 0xC0
- sw1GetResponse = 0x61
- sw1Ok = 0x90
-
- insVerifyPin = 0x20
- insUnblockPin = 0x22
- insExportKey = 0xC2
- insSign = 0xC0
- insLoadKey = 0xD0
- insDeriveKey = 0xD1
- insStatus = 0xF2
-)
-
-// List of ADPU command parameters
-const (
- P1DeriveKeyFromMaster = uint8(0x00)
- P1DeriveKeyFromParent = uint8(0x01)
- P1DeriveKeyFromCurrent = uint8(0x10)
- statusP1WalletStatus = uint8(0x00)
- statusP1Path = uint8(0x01)
- signP1PrecomputedHash = uint8(0x00)
- signP2OnlyBlock = uint8(0x00)
- exportP1Any = uint8(0x00)
- exportP2Pubkey = uint8(0x01)
-)
-
-// Minimum time to wait between self derivation attempts, even it the user is
-// requesting accounts like crazy.
-const selfDeriveThrottling = time.Second
-
-// Wallet represents a smartcard wallet instance.
-type Wallet struct {
- Hub *Hub // A handle to the Hub that instantiated this wallet.
- PublicKey []byte // The wallet's public key (used for communication and identification, not signing!)
-
- lock sync.Mutex // Lock that gates access to struct fields and communication with the card
- card *pcsc.Card // A handle to the smartcard interface for the wallet.
- session *Session // The secure communication session with the card
- log log.Logger // Contextual logger to tag the base with its id
-
- deriveNextPaths []accounts.DerivationPath // Next derivation paths for account auto-discovery (multiple bases supported)
- deriveNextAddrs []common.Address // Next derived account addresses for auto-discovery (multiple bases supported)
- deriveChain ethereum.ChainStateReader // Blockchain state reader to discover used account with
- deriveReq chan chan struct{} // Channel to request a self-derivation on
- deriveQuit chan chan error // Channel to terminate the self-deriver with
-}
-
-// NewWallet constructs and returns a new Wallet instance.
-func NewWallet(hub *Hub, card *pcsc.Card) *Wallet {
- wallet := &Wallet{
- Hub: hub,
- card: card,
- }
- return wallet
-}
-
-// transmit sends an APDU to the smartcard and receives and decodes the response.
-// It automatically handles requests by the card to fetch the return data separately,
-// and returns an error if the response status code is not success.
-func transmit(card *pcsc.Card, command *commandAPDU) (*responseAPDU, error) {
- data, err := command.serialize()
- if err != nil {
- return nil, err
- }
-
- responseData, _, err := card.Transmit(data)
- if err != nil {
- return nil, err
- }
-
- response := new(responseAPDU)
- if err = response.deserialize(responseData); err != nil {
- return nil, err
- }
-
- // Are we being asked to fetch the response separately?
- if response.Sw1 == sw1GetResponse && (command.Cla != claISO7816 || command.Ins != insGetResponse) {
- return transmit(card, &commandAPDU{
- Cla: claISO7816,
- Ins: insGetResponse,
- P1: 0,
- P2: 0,
- Data: nil,
- Le: response.Sw2,
- })
- }
-
- if response.Sw1 != sw1Ok {
- return nil, fmt.Errorf("unexpected insecure response status Cla=%#x, Ins=%#x, Sw=%#x%x", command.Cla, command.Ins, response.Sw1, response.Sw2)
- }
-
- return response, nil
-}
-
-// applicationInfo encodes information about the smartcard application - its
-// instance UID and public key.
-type applicationInfo struct {
- InstanceUID []byte `asn1:"tag:15"`
- PublicKey []byte `asn1:"tag:0"`
-}
-
-// connect connects to the wallet application and establishes a secure channel with it.
-// must be called before any other interaction with the wallet.
-func (w *Wallet) connect() error {
- w.lock.Lock()
- defer w.lock.Unlock()
-
- appinfo, err := w.doselect()
- if err != nil {
- return err
- }
-
- channel, err := NewSecureChannelSession(w.card, appinfo.PublicKey)
- if err != nil {
- return err
- }
-
- w.PublicKey = appinfo.PublicKey
- w.log = log.New("url", w.URL())
- w.session = &Session{
- Wallet: w,
- Channel: channel,
- }
- return nil
-}
-
-// doselect is an internal (unlocked) function to send a SELECT APDU to the card.
-func (w *Wallet) doselect() (*applicationInfo, error) {
- response, err := transmit(w.card, &commandAPDU{
- Cla: claISO7816,
- Ins: insSelect,
- P1: 4,
- P2: 0,
- Data: appletAID,
- })
- if err != nil {
- return nil, err
- }
-
- appinfo := new(applicationInfo)
- if _, err := asn1.UnmarshalWithParams(response.Data, appinfo, "tag:4"); err != nil {
- return nil, err
- }
- return appinfo, nil
-}
-
-// ping checks the card's status and returns an error if unsuccessful.
-func (w *Wallet) ping() error {
- w.lock.Lock()
- defer w.lock.Unlock()
-
- // We can't ping if not paired
- if !w.session.paired() {
- return nil
- }
- if _, err := w.session.walletStatus(); err != nil {
- return err
- }
- return nil
-}
-
-// release releases any resources held by an open wallet instance.
-func (w *Wallet) release() error {
- if w.session != nil {
- return w.session.release()
- }
- return nil
-}
-
-// pair is an internal (unlocked) function for establishing a new pairing
-// with the wallet.
-func (w *Wallet) pair(puk []byte) error {
- if w.session.paired() {
- return errors.New("wallet already paired")
- }
- pairing, err := w.session.pair(puk)
- if err != nil {
- return err
- }
- if err = w.Hub.setPairing(w, &pairing); err != nil {
- return err
- }
- return w.session.authenticate(pairing)
-}
-
-// Unpair deletes an existing wallet pairing.
-func (w *Wallet) Unpair(pin []byte) error {
- w.lock.Lock()
- defer w.lock.Unlock()
-
- if !w.session.paired() {
- return fmt.Errorf("wallet %x not paired", w.PublicKey)
- }
- if err := w.session.verifyPin(pin); err != nil {
- return fmt.Errorf("failed to verify pin: %s", err)
- }
- if err := w.session.unpair(); err != nil {
- return fmt.Errorf("failed to unpair: %s", err)
- }
- if err := w.Hub.setPairing(w, nil); err != nil {
- return err
- }
- return nil
-}
-
-// URL retrieves the canonical path under which this wallet is reachable. It is
-// user by upper layers to define a sorting order over all wallets from multiple
-// backends.
-func (w *Wallet) URL() accounts.URL {
- return accounts.URL{
- Scheme: w.Hub.scheme,
- Path: fmt.Sprintf("%x", w.PublicKey[1:5]), // Byte #0 isn't unique; 1:5 covers << 64K cards, bump to 1:9 for << 4M
- }
-}
-
-// Status returns a textual status to aid the user in the current state of the
-// wallet. It also returns an error indicating any failure the wallet might have
-// encountered.
-func (w *Wallet) Status() (string, error) {
- w.lock.Lock()
- defer w.lock.Unlock()
-
- // If the card is not paired, we can only wait
- if !w.session.paired() {
- return "Unpaired, waiting for pairing password", nil
- }
- // Yay, we have an encrypted session, retrieve the actual status
- status, err := w.session.walletStatus()
- if err != nil {
- return fmt.Sprintf("Failed: %v", err), err
- }
- switch {
- case !w.session.verified && status.PinRetryCount == 0 && status.PukRetryCount == 0:
- return "Bricked, waiting for full wipe", nil
- case !w.session.verified && status.PinRetryCount == 0:
- return fmt.Sprintf("Blocked, waiting for PUK (%d attempts left) and new PIN", status.PukRetryCount), nil
- case !w.session.verified:
- return fmt.Sprintf("Locked, waiting for PIN (%d attempts left)", status.PinRetryCount), nil
- case !status.Initialized:
- return "Empty, waiting for initialization", nil
- default:
- return "Online", nil
- }
-}
-
-// Open initializes access to a wallet instance. It is not meant to unlock or
-// decrypt account keys, rather simply to establish a connection to hardware
-// wallets and/or to access derivation seeds.
-//
-// The passphrase parameter may or may not be used by the implementation of a
-// particular wallet instance. The reason there is no passwordless open method
-// is to strive towards a uniform wallet handling, oblivious to the different
-// backend providers.
-//
-// Please note, if you open a wallet, you must close it to release any allocated
-// resources (especially important when working with hardware wallets).
-func (w *Wallet) Open(passphrase string) error {
- w.lock.Lock()
- defer w.lock.Unlock()
-
- // If the session is already open, bail out
- if w.session.verified {
- return ErrAlreadyOpen
- }
- // If the smart card is not yet paired, attempt to do so either from a previous
- // pairing key or form the supplied PUK code.
- if !w.session.paired() {
- // If a previous pairing exists, only ever try to use that
- if pairing := w.Hub.pairing(w); pairing != nil {
- if err := w.session.authenticate(*pairing); err != nil {
- return fmt.Errorf("failed to authenticate card %x: %s", w.PublicKey[:4], err)
- }
- // Pairing still ok, fall through to PIN checks
- } else {
- // If no passphrase was supplied, request the PUK from the user
- if passphrase == "" {
- return ErrPairingPasswordNeeded
- }
- // Attempt to pair the smart card with the user supplied PUK
- if err := w.pair([]byte(passphrase)); err != nil {
- return err
- }
- // Pairing succeeded, fall through to PIN checks. This will of course fail,
- // but we can't return ErrPINNeeded directly here because we don't know whether
- // a PIN check or a PIN reset is needed.
- passphrase = ""
- }
- }
- // The smart card was successfully paired, retrieve its status to check whether
- // PIN verification or unblocking is needed.
- status, err := w.session.walletStatus()
- if err != nil {
- return err
- }
- // Request the appropriate next authentication data, or use the one supplied
- switch {
- case passphrase == "" && status.PinRetryCount > 0:
- return ErrPINNeeded
- case passphrase == "":
- return ErrPINUnblockNeeded
- case status.PinRetryCount > 0:
- if !regexp.MustCompile(`^[0-9]{6,}$`).MatchString(passphrase) {
- w.log.Error("PIN needs to be at least 6 digits")
- return ErrPINNeeded
- }
- if err := w.session.verifyPin([]byte(passphrase)); err != nil {
- return err
- }
- default:
- if !regexp.MustCompile(`^[0-9]{12,}$`).MatchString(passphrase) {
- w.log.Error("PUK needs to be at least 12 digits")
- return ErrPINUnblockNeeded
- }
- if err := w.session.unblockPin([]byte(passphrase)); err != nil {
- return err
- }
- }
- // Smart card paired and unlocked, initialize and register
- w.deriveReq = make(chan chan struct{})
- w.deriveQuit = make(chan chan error)
-
- go w.selfDerive()
-
- // Notify anyone listening for wallet events that a new device is accessible
- go w.Hub.updateFeed.Send(accounts.WalletEvent{Wallet: w, Kind: accounts.WalletOpened})
-
- return nil
-}
-
-// Close stops and closes the wallet, freeing any resources.
-func (w *Wallet) Close() error {
- // Ensure the wallet was opened
- w.lock.Lock()
- dQuit := w.deriveQuit
- w.lock.Unlock()
-
- // Terminate the self-derivations
- var derr error
- if dQuit != nil {
- errc := make(chan error)
- dQuit <- errc
- derr = <-errc // Save for later, we *must* close the USB
- }
- // Terminate the device connection
- w.lock.Lock()
- defer w.lock.Unlock()
-
- w.deriveQuit = nil
- w.deriveReq = nil
-
- if err := w.release(); err != nil {
- return err
- }
- return derr
-}
-
-// selfDerive is an account derivation loop that upon request attempts to find
-// new non-zero accounts.
-func (w *Wallet) selfDerive() {
- w.log.Debug("Smart card wallet self-derivation started")
- defer w.log.Debug("Smart card wallet self-derivation stopped")
-
- // Execute self-derivations until termination or error
- var (
- reqc chan struct{}
- errc chan error
- err error
- )
- for errc == nil && err == nil {
- // Wait until either derivation or termination is requested
- select {
- case errc = <-w.deriveQuit:
- // Termination requested
- continue
- case reqc = <-w.deriveReq:
- // Account discovery requested
- }
- // Derivation needs a chain and device access, skip if either unavailable
- w.lock.Lock()
- if w.session == nil || w.deriveChain == nil {
- w.lock.Unlock()
- reqc <- struct{}{}
- continue
- }
- pairing := w.Hub.pairing(w)
-
- // Device lock obtained, derive the next batch of accounts
- var (
- paths []accounts.DerivationPath
- nextAcc accounts.Account
-
- nextPaths = append([]accounts.DerivationPath{}, w.deriveNextPaths...)
- nextAddrs = append([]common.Address{}, w.deriveNextAddrs...)
-
- context = context.Background()
- )
- for i := 0; i < len(nextAddrs); i++ {
- for empty := false; !empty; {
- // Retrieve the next derived Ethereum account
- if nextAddrs[i] == (common.Address{}) {
- if nextAcc, err = w.session.derive(nextPaths[i]); err != nil {
- w.log.Warn("Smartcard wallet account derivation failed", "err", err)
- break
- }
- nextAddrs[i] = nextAcc.Address
- }
- // Check the account's status against the current chain state
- var (
- balance *big.Int
- nonce uint64
- )
- balance, err = w.deriveChain.BalanceAt(context, nextAddrs[i], nil)
- if err != nil {
- w.log.Warn("Smartcard wallet balance retrieval failed", "err", err)
- break
- }
- nonce, err = w.deriveChain.NonceAt(context, nextAddrs[i], nil)
- if err != nil {
- w.log.Warn("Smartcard wallet nonce retrieval failed", "err", err)
- break
- }
- // If the next account is empty, stop self-derivation, but add for the last base path
- if balance.Sign() == 0 && nonce == 0 {
- empty = true
- if i < len(nextAddrs)-1 {
- break
- }
- }
- // We've just self-derived a new account, start tracking it locally
- path := make(accounts.DerivationPath, len(nextPaths[i]))
- copy(path[:], nextPaths[i][:])
- paths = append(paths, path)
-
- // Display a log message to the user for new (or previously empty accounts)
- if _, known := pairing.Accounts[nextAddrs[i]]; !known || !empty || nextAddrs[i] != w.deriveNextAddrs[i] {
- w.log.Info("Smartcard wallet discovered new account", "address", nextAddrs[i], "path", path, "balance", balance, "nonce", nonce)
- }
- pairing.Accounts[nextAddrs[i]] = path
-
- // Fetch the next potential account
- if !empty {
- nextAddrs[i] = common.Address{}
- nextPaths[i][len(nextPaths[i])-1]++
- }
- }
- }
- // If there are new accounts, write them out
- if len(paths) > 0 {
- err = w.Hub.setPairing(w, pairing)
- }
- // Shift the self-derivation forward
- w.deriveNextAddrs = nextAddrs
- w.deriveNextPaths = nextPaths
-
- // Self derivation complete, release device lock
- w.lock.Unlock()
-
- // Notify the user of termination and loop after a bit of time (to avoid trashing)
- reqc <- struct{}{}
- if err == nil {
- select {
- case errc = <-w.deriveQuit:
- // Termination requested, abort
- case <-time.After(selfDeriveThrottling):
- // Waited enough, willing to self-derive again
- }
- }
- }
- // In case of error, wait for termination
- if err != nil {
- w.log.Debug("Smartcard wallet self-derivation failed", "err", err)
- errc = <-w.deriveQuit
- }
- errc <- err
-}
-
-// Accounts retrieves the list of signing accounts the wallet is currently aware
-// of. For hierarchical deterministic wallets, the list will not be exhaustive,
-// rather only contain the accounts explicitly pinned during account derivation.
-func (w *Wallet) Accounts() []accounts.Account {
- // Attempt self-derivation if it's running
- reqc := make(chan struct{}, 1)
- select {
- case w.deriveReq <- reqc:
- // Self-derivation request accepted, wait for it
- <-reqc
- default:
- // Self-derivation offline, throttled or busy, skip
- }
-
- w.lock.Lock()
- defer w.lock.Unlock()
-
- if pairing := w.Hub.pairing(w); pairing != nil {
- ret := make([]accounts.Account, 0, len(pairing.Accounts))
- for address, path := range pairing.Accounts {
- ret = append(ret, w.makeAccount(address, path))
- }
- sort.Sort(accounts.AccountsByURL(ret))
- return ret
- }
- return nil
-}
-
-func (w *Wallet) makeAccount(address common.Address, path accounts.DerivationPath) accounts.Account {
- return accounts.Account{
- Address: address,
- URL: accounts.URL{
- Scheme: w.Hub.scheme,
- Path: fmt.Sprintf("%x/%s", w.PublicKey[1:3], path.String()),
- },
- }
-}
-
-// Contains returns whether an account is part of this particular wallet or not.
-func (w *Wallet) Contains(account accounts.Account) bool {
- if pairing := w.Hub.pairing(w); pairing != nil {
- _, ok := pairing.Accounts[account.Address]
- return ok
- }
- return false
-}
-
-// Initialize installs a keypair generated from the provided key into the wallet.
-func (w *Wallet) Initialize(seed []byte) error {
- go w.selfDerive()
- // DO NOT lock at this stage, as the initialize
- // function relies on Status()
- return w.session.initialize(seed)
-}
-
-// Derive attempts to explicitly derive a hierarchical deterministic account at
-// the specified derivation path. If requested, the derived account will be added
-// to the wallet's tracked account list.
-func (w *Wallet) Derive(path accounts.DerivationPath, pin bool) (accounts.Account, error) {
- w.lock.Lock()
- defer w.lock.Unlock()
-
- account, err := w.session.derive(path)
- if err != nil {
- return accounts.Account{}, err
- }
-
- if pin {
- pairing := w.Hub.pairing(w)
- pairing.Accounts[account.Address] = path
- if err := w.Hub.setPairing(w, pairing); err != nil {
- return accounts.Account{}, err
- }
- }
-
- return account, nil
-}
-
-// SelfDerive sets a base account derivation path from which the wallet attempts
-// to discover non zero accounts and automatically add them to list of tracked
-// accounts.
-//
-// Note, self derivation will increment the last component of the specified path
-// opposed to descending into a child path to allow discovering accounts starting
-// from non zero components.
-//
-// Some hardware wallets switched derivation paths through their evolution, so
-// this method supports providing multiple bases to discover old user accounts
-// too. Only the last base will be used to derive the next empty account.
-//
-// You can disable automatic account discovery by calling SelfDerive with a nil
-// chain state reader.
-func (w *Wallet) SelfDerive(bases []accounts.DerivationPath, chain ethereum.ChainStateReader) {
- w.lock.Lock()
- defer w.lock.Unlock()
-
- w.deriveNextPaths = make([]accounts.DerivationPath, len(bases))
- for i, base := range bases {
- w.deriveNextPaths[i] = make(accounts.DerivationPath, len(base))
- copy(w.deriveNextPaths[i][:], base[:])
- }
- w.deriveNextAddrs = make([]common.Address, len(bases))
- w.deriveChain = chain
-}
-
-// SignData requests the wallet to sign the hash of the given data.
-//
-// It looks up the account specified either solely via its address contained within,
-// or optionally with the aid of any location metadata from the embedded URL field.
-//
-// If the wallet requires additional authentication to sign the request (e.g.
-// a password to decrypt the account, or a PIN code o verify the transaction),
-// an AuthNeededError instance will be returned, containing infos for the user
-// about which fields or actions are needed. The user may retry by providing
-// the needed details via SignDataWithPassphrase, or by other means (e.g. unlock
-// the account in a keystore).
-func (w *Wallet) SignData(account accounts.Account, mimeType string, data []byte) ([]byte, error) {
- return w.signHash(account, crypto.Keccak256(data))
-}
-
-func (w *Wallet) signHash(account accounts.Account, hash []byte) ([]byte, error) {
- w.lock.Lock()
- defer w.lock.Unlock()
-
- path, err := w.findAccountPath(account)
- if err != nil {
- return nil, err
- }
-
- return w.session.sign(path, hash)
-}
-
-// SignTx requests the wallet to sign the given transaction.
-//
-// It looks up the account specified either solely via its address contained within,
-// or optionally with the aid of any location metadata from the embedded URL field.
-//
-// If the wallet requires additional authentication to sign the request (e.g.
-// a password to decrypt the account, or a PIN code o verify the transaction),
-// an AuthNeededError instance will be returned, containing infos for the user
-// about which fields or actions are needed. The user may retry by providing
-// the needed details via SignTxWithPassphrase, or by other means (e.g. unlock
-// the account in a keystore).
-func (w *Wallet) SignTx(account accounts.Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
- signer := types.LatestSignerForChainID(chainID)
- hash := signer.Hash(tx)
- sig, err := w.signHash(account, hash[:])
- if err != nil {
- return nil, err
- }
- return tx.WithSignature(signer, sig)
-}
-
-// SignDataWithPassphrase requests the wallet to sign the given hash with the
-// given passphrase as extra authentication information.
-//
-// It looks up the account specified either solely via its address contained within,
-// or optionally with the aid of any location metadata from the embedded URL field.
-func (w *Wallet) SignDataWithPassphrase(account accounts.Account, passphrase, mimeType string, data []byte) ([]byte, error) {
- return w.signHashWithPassphrase(account, passphrase, crypto.Keccak256(data))
-}
-
-func (w *Wallet) signHashWithPassphrase(account accounts.Account, passphrase string, hash []byte) ([]byte, error) {
- if !w.session.verified {
- if err := w.Open(passphrase); err != nil {
- return nil, err
- }
- }
-
- return w.signHash(account, hash)
-}
-
-// SignText requests the wallet to sign the hash of a given piece of data, prefixed
-// by the Ethereum prefix scheme
-// It looks up the account specified either solely via its address contained within,
-// or optionally with the aid of any location metadata from the embedded URL field.
-//
-// If the wallet requires additional authentication to sign the request (e.g.
-// a password to decrypt the account, or a PIN code o verify the transaction),
-// an AuthNeededError instance will be returned, containing infos for the user
-// about which fields or actions are needed. The user may retry by providing
-// the needed details via SignHashWithPassphrase, or by other means (e.g. unlock
-// the account in a keystore).
-func (w *Wallet) SignText(account accounts.Account, text []byte) ([]byte, error) {
- return w.signHash(account, accounts.TextHash(text))
-}
-
-// SignTextWithPassphrase implements accounts.Wallet, attempting to sign the
-// given hash with the given account using passphrase as extra authentication
-func (w *Wallet) SignTextWithPassphrase(account accounts.Account, passphrase string, text []byte) ([]byte, error) {
- return w.signHashWithPassphrase(account, passphrase, crypto.Keccak256(accounts.TextHash(text)))
-}
-
-// SignTxWithPassphrase requests the wallet to sign the given transaction, with the
-// given passphrase as extra authentication information.
-//
-// It looks up the account specified either solely via its address contained within,
-// or optionally with the aid of any location metadata from the embedded URL field.
-func (w *Wallet) SignTxWithPassphrase(account accounts.Account, passphrase string, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
- if !w.session.verified {
- if err := w.Open(passphrase); err != nil {
- return nil, err
- }
- }
- return w.SignTx(account, tx, chainID)
-}
-
-// findAccountPath returns the derivation path for the provided account.
-// It first checks for the address in the list of pinned accounts, and if it is
-// not found, attempts to parse the derivation path from the account's URL.
-func (w *Wallet) findAccountPath(account accounts.Account) (accounts.DerivationPath, error) {
- pairing := w.Hub.pairing(w)
- if path, ok := pairing.Accounts[account.Address]; ok {
- return path, nil
- }
-
- // Look for the path in the URL
- if account.URL.Scheme != w.Hub.scheme {
- return nil, fmt.Errorf("scheme %s does not match wallet scheme %s", account.URL.Scheme, w.Hub.scheme)
- }
-
- url, path, found := strings.Cut(account.URL.Path, "/")
- if !found {
- return nil, fmt.Errorf("invalid URL format: %s", account.URL)
- }
-
- if url != fmt.Sprintf("%x", w.PublicKey[1:3]) {
- return nil, fmt.Errorf("URL %s is not for this wallet", account.URL)
- }
-
- return accounts.ParseDerivationPath(path)
-}
-
-// Session represents a secured communication session with the wallet.
-type Session struct {
- Wallet *Wallet // A handle to the wallet that opened the session
- Channel *SecureChannelSession // A secure channel for encrypted messages
- verified bool // Whether the pin has been verified in this session.
-}
-
-// pair establishes a new pairing over this channel, using the provided secret.
-func (s *Session) pair(secret []byte) (smartcardPairing, error) {
- err := s.Channel.Pair(secret)
- if err != nil {
- return smartcardPairing{}, err
- }
-
- return smartcardPairing{
- PublicKey: s.Wallet.PublicKey,
- PairingIndex: s.Channel.PairingIndex,
- PairingKey: s.Channel.PairingKey,
- Accounts: make(map[common.Address]accounts.DerivationPath),
- }, nil
-}
-
-// unpair deletes an existing pairing.
-func (s *Session) unpair() error {
- if !s.verified {
- return errors.New("unpair requires that the PIN be verified")
- }
- return s.Channel.Unpair()
-}
-
-// verifyPin unlocks a wallet with the provided pin.
-func (s *Session) verifyPin(pin []byte) error {
- if _, err := s.Channel.transmitEncrypted(claSCWallet, insVerifyPin, 0, 0, pin); err != nil {
- return err
- }
- s.verified = true
- return nil
-}
-
-// unblockPin unblocks a wallet with the provided puk and resets the pin to the
-// new one specified.
-func (s *Session) unblockPin(pukpin []byte) error {
- if _, err := s.Channel.transmitEncrypted(claSCWallet, insUnblockPin, 0, 0, pukpin); err != nil {
- return err
- }
- s.verified = true
- return nil
-}
-
-// release releases resources associated with the channel.
-func (s *Session) release() error {
- return s.Wallet.card.Disconnect(pcsc.LeaveCard)
-}
-
-// paired returns true if a valid pairing exists.
-func (s *Session) paired() bool {
- return s.Channel.PairingKey != nil
-}
-
-// authenticate uses an existing pairing to establish a secure channel.
-func (s *Session) authenticate(pairing smartcardPairing) error {
- if !bytes.Equal(s.Wallet.PublicKey, pairing.PublicKey) {
- return fmt.Errorf("cannot pair using another wallet's pairing; %x != %x", s.Wallet.PublicKey, pairing.PublicKey)
- }
- s.Channel.PairingKey = pairing.PairingKey
- s.Channel.PairingIndex = pairing.PairingIndex
- return s.Channel.Open()
-}
-
-// walletStatus describes a smartcard wallet's status information.
-type walletStatus struct {
- PinRetryCount int // Number of remaining PIN retries
- PukRetryCount int // Number of remaining PUK retries
- Initialized bool // Whether the card has been initialized with a private key
-}
-
-// walletStatus fetches the wallet's status from the card.
-func (s *Session) walletStatus() (*walletStatus, error) {
- response, err := s.Channel.transmitEncrypted(claSCWallet, insStatus, statusP1WalletStatus, 0, nil)
- if err != nil {
- return nil, err
- }
-
- status := new(walletStatus)
- if _, err := asn1.UnmarshalWithParams(response.Data, status, "tag:3"); err != nil {
- return nil, err
- }
- return status, nil
-}
-
-// derivationPath fetches the wallet's current derivation path from the card.
-//
-//lint:ignore U1000 needs to be added to the console interface
-func (s *Session) derivationPath() (accounts.DerivationPath, error) {
- response, err := s.Channel.transmitEncrypted(claSCWallet, insStatus, statusP1Path, 0, nil)
- if err != nil {
- return nil, err
- }
- buf := bytes.NewReader(response.Data)
- path := make(accounts.DerivationPath, len(response.Data)/4)
- return path, binary.Read(buf, binary.BigEndian, &path)
-}
-
-// initializeData contains data needed to initialize the smartcard wallet.
-type initializeData struct {
- PublicKey []byte `asn1:"tag:0"`
- PrivateKey []byte `asn1:"tag:1"`
- ChainCode []byte `asn1:"tag:2"`
-}
-
-// initialize initializes the card with new key data.
-func (s *Session) initialize(seed []byte) error {
- // Check that the wallet isn't currently initialized,
- // otherwise the key would be overwritten.
- status, err := s.Wallet.Status()
- if err != nil {
- return err
- }
- if status == "Online" {
- return errors.New("card is already initialized, cowardly refusing to proceed")
- }
-
- s.Wallet.lock.Lock()
- defer s.Wallet.lock.Unlock()
-
- // HMAC the seed to produce the private key and chain code
- mac := hmac.New(sha512.New, []byte("Bitcoin seed"))
- mac.Write(seed)
- seed = mac.Sum(nil)
-
- key, err := crypto.ToECDSA(seed[:32])
- if err != nil {
- return err
- }
-
- id := initializeData{}
- id.PublicKey = crypto.FromECDSAPub(&key.PublicKey)
- id.PrivateKey = seed[:32]
- id.ChainCode = seed[32:]
- data, err := asn1.Marshal(id)
- if err != nil {
- return err
- }
-
- // Nasty hack to force the top-level struct tag to be context-specific
- data[0] = 0xA1
-
- _, err = s.Channel.transmitEncrypted(claSCWallet, insLoadKey, 0x02, 0, data)
- return err
-}
-
-// derive derives a new HD key path on the card.
-func (s *Session) derive(path accounts.DerivationPath) (accounts.Account, error) {
- startingPoint, path, err := derivationpath.Decode(path.String())
- if err != nil {
- return accounts.Account{}, err
- }
-
- var p1 uint8
- switch startingPoint {
- case derivationpath.StartingPointMaster:
- p1 = P1DeriveKeyFromMaster
- case derivationpath.StartingPointParent:
- p1 = P1DeriveKeyFromParent
- case derivationpath.StartingPointCurrent:
- p1 = P1DeriveKeyFromCurrent
- default:
- return accounts.Account{}, fmt.Errorf("invalid startingPoint %d", startingPoint)
- }
-
- data := new(bytes.Buffer)
- for _, segment := range path {
- if err := binary.Write(data, binary.BigEndian, segment); err != nil {
- return accounts.Account{}, err
- }
- }
-
- _, err = s.Channel.transmitEncrypted(claSCWallet, insDeriveKey, p1, 0, data.Bytes())
- if err != nil {
- return accounts.Account{}, err
- }
-
- response, err := s.Channel.transmitEncrypted(claSCWallet, insSign, 0, 0, DerivationSignatureHash[:])
- if err != nil {
- return accounts.Account{}, err
- }
-
- sigdata := new(signatureData)
- if _, err := asn1.UnmarshalWithParams(response.Data, sigdata, "tag:0"); err != nil {
- return accounts.Account{}, err
- }
- rbytes, sbytes := sigdata.Signature.R.Bytes(), sigdata.Signature.S.Bytes()
- sig := make([]byte, 65)
- copy(sig[32-len(rbytes):32], rbytes)
- copy(sig[64-len(sbytes):64], sbytes)
-
- if err := confirmPublicKey(sig, sigdata.PublicKey); err != nil {
- return accounts.Account{}, err
- }
- pub, err := crypto.UnmarshalPubkey(sigdata.PublicKey)
- if err != nil {
- return accounts.Account{}, err
- }
- return s.Wallet.makeAccount(crypto.PubkeyToAddress(*pub), path), nil
-}
-
-// keyExport contains information on an exported keypair.
-//
-//lint:ignore U1000 needs to be added to the console interface
-type keyExport struct {
- PublicKey []byte `asn1:"tag:0"`
- PrivateKey []byte `asn1:"tag:1,optional"`
-}
-
-// publicKey returns the public key for the current derivation path.
-//
-//lint:ignore U1000 needs to be added to the console interface
-func (s *Session) publicKey() ([]byte, error) {
- response, err := s.Channel.transmitEncrypted(claSCWallet, insExportKey, exportP1Any, exportP2Pubkey, nil)
- if err != nil {
- return nil, err
- }
- keys := new(keyExport)
- if _, err := asn1.UnmarshalWithParams(response.Data, keys, "tag:1"); err != nil {
- return nil, err
- }
- return keys.PublicKey, nil
-}
-
-// signatureData contains information on a signature - the signature itself and
-// the corresponding public key.
-type signatureData struct {
- PublicKey []byte `asn1:"tag:0"`
- Signature struct {
- R *big.Int
- S *big.Int
- }
-}
-
-// sign asks the card to sign a message, and returns a valid signature after
-// recovering the v value.
-func (s *Session) sign(path accounts.DerivationPath, hash []byte) ([]byte, error) {
- startTime := time.Now()
- _, err := s.derive(path)
- if err != nil {
- return nil, err
- }
- deriveTime := time.Now()
-
- response, err := s.Channel.transmitEncrypted(claSCWallet, insSign, signP1PrecomputedHash, signP2OnlyBlock, hash)
- if err != nil {
- return nil, err
- }
- sigdata := new(signatureData)
- if _, err := asn1.UnmarshalWithParams(response.Data, sigdata, "tag:0"); err != nil {
- return nil, err
- }
- // Serialize the signature
- rbytes, sbytes := sigdata.Signature.R.Bytes(), sigdata.Signature.S.Bytes()
- sig := make([]byte, 65)
- copy(sig[32-len(rbytes):32], rbytes)
- copy(sig[64-len(sbytes):64], sbytes)
-
- // Recover the V value.
- sig, err = makeRecoverableSignature(hash, sig, sigdata.PublicKey)
- if err != nil {
- return nil, err
- }
- log.Debug("Signed using smartcard", "deriveTime", deriveTime.Sub(startTime), "signingTime", time.Since(deriveTime))
-
- return sig, nil
-}
-
-// confirmPublicKey confirms that the given signature belongs to the specified key.
-func confirmPublicKey(sig, pubkey []byte) error {
- _, err := makeRecoverableSignature(DerivationSignatureHash[:], sig, pubkey)
- return err
-}
-
-// makeRecoverableSignature uses a signature and an expected public key to
-// recover the v value and produce a recoverable signature.
-func makeRecoverableSignature(hash, sig, expectedPubkey []byte) ([]byte, error) {
- var libraryError error
- for v := 0; v < 2; v++ {
- sig[64] = byte(v)
- if pubkey, err := crypto.Ecrecover(hash, sig); err == nil {
- if bytes.Equal(pubkey, expectedPubkey) {
- return sig, nil
- }
- } else {
- libraryError = err
- }
- }
- if libraryError != nil {
- return nil, libraryError
- }
- return nil, ErrPubkeyMismatch
-}
diff --git a/accounts/sort.go b/accounts/sort.go
deleted file mode 100644
index f46762114a..0000000000
--- a/accounts/sort.go
+++ /dev/null
@@ -1,31 +0,0 @@
-// 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 accounts
-
-// AccountsByURL implements sort.Interface for []Account based on the URL field.
-type AccountsByURL []Account
-
-func (a AccountsByURL) Len() int { return len(a) }
-func (a AccountsByURL) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
-func (a AccountsByURL) Less(i, j int) bool { return a[i].URL.Cmp(a[j].URL) < 0 }
-
-// WalletsByURL implements sort.Interface for []Wallet based on the URL field.
-type WalletsByURL []Wallet
-
-func (w WalletsByURL) Len() int { return len(w) }
-func (w WalletsByURL) Swap(i, j int) { w[i], w[j] = w[j], w[i] }
-func (w WalletsByURL) Less(i, j int) bool { return w[i].URL().Cmp(w[j].URL()) < 0 }
diff --git a/accounts/url.go b/accounts/url.go
deleted file mode 100644
index 39b00e5b44..0000000000
--- a/accounts/url.go
+++ /dev/null
@@ -1,103 +0,0 @@
-// 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 accounts
-
-import (
- "encoding/json"
- "errors"
- "fmt"
- "strings"
-)
-
-// URL represents the canonical identification URL of a wallet or account.
-//
-// It is a simplified version of url.URL, with the important limitations (which
-// are considered features here) that it contains value-copyable components only,
-// as well as that it doesn't do any URL encoding/decoding of special characters.
-//
-// The former is important to allow an account to be copied without leaving live
-// references to the original version, whereas the latter is important to ensure
-// one single canonical form opposed to many allowed ones by the RFC 3986 spec.
-//
-// As such, these URLs should not be used outside of the scope of an Ethereum
-// wallet or account.
-type URL struct {
- Scheme string // Protocol scheme to identify a capable account backend
- Path string // Path for the backend to identify a unique entity
-}
-
-// parseURL converts a user supplied URL into the accounts specific structure.
-func parseURL(url string) (URL, error) {
- parts := strings.Split(url, "://")
- if len(parts) != 2 || parts[0] == "" {
- return URL{}, errors.New("protocol scheme missing")
- }
- return URL{
- Scheme: parts[0],
- Path: parts[1],
- }, nil
-}
-
-// String implements the stringer interface.
-func (u URL) String() string {
- if u.Scheme != "" {
- return fmt.Sprintf("%s://%s", u.Scheme, u.Path)
- }
- return u.Path
-}
-
-// TerminalString implements the log.TerminalStringer interface.
-func (u URL) TerminalString() string {
- url := u.String()
- if len(url) > 32 {
- return url[:31] + ".."
- }
- return url
-}
-
-// MarshalJSON implements the json.Marshaller interface.
-func (u URL) MarshalJSON() ([]byte, error) {
- return json.Marshal(u.String())
-}
-
-// UnmarshalJSON parses url.
-func (u *URL) UnmarshalJSON(input []byte) error {
- var textURL string
- err := json.Unmarshal(input, &textURL)
- if err != nil {
- return err
- }
- url, err := parseURL(textURL)
- if err != nil {
- return err
- }
- u.Scheme = url.Scheme
- u.Path = url.Path
- return nil
-}
-
-// Cmp compares x and y and returns:
-//
-// -1 if x < y
-// 0 if x == y
-// +1 if x > y
-func (u URL) Cmp(url URL) int {
- if u.Scheme == url.Scheme {
- return strings.Compare(u.Path, url.Path)
- }
- return strings.Compare(u.Scheme, url.Scheme)
-}
diff --git a/accounts/url_test.go b/accounts/url_test.go
deleted file mode 100644
index f481a1016d..0000000000
--- a/accounts/url_test.go
+++ /dev/null
@@ -1,102 +0,0 @@
-// 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 accounts
-
-import (
- "testing"
-)
-
-func TestURLParsing(t *testing.T) {
- t.Parallel()
- url, err := parseURL("https://ethereum.org")
- if err != nil {
- t.Errorf("unexpected error: %v", err)
- }
- if url.Scheme != "https" {
- t.Errorf("expected: %v, got: %v", "https", url.Scheme)
- }
- if url.Path != "ethereum.org" {
- t.Errorf("expected: %v, got: %v", "ethereum.org", url.Path)
- }
-
- for _, u := range []string{"ethereum.org", ""} {
- if _, err = parseURL(u); err == nil {
- t.Errorf("input %v, expected err, got: nil", u)
- }
- }
-}
-
-func TestURLString(t *testing.T) {
- t.Parallel()
- url := URL{Scheme: "https", Path: "ethereum.org"}
- if url.String() != "https://ethereum.org" {
- t.Errorf("expected: %v, got: %v", "https://ethereum.org", url.String())
- }
-
- url = URL{Scheme: "", Path: "ethereum.org"}
- if url.String() != "ethereum.org" {
- t.Errorf("expected: %v, got: %v", "ethereum.org", url.String())
- }
-}
-
-func TestURLMarshalJSON(t *testing.T) {
- t.Parallel()
- url := URL{Scheme: "https", Path: "ethereum.org"}
- json, err := url.MarshalJSON()
- if err != nil {
- t.Errorf("unexpected error: %v", err)
- }
- if string(json) != "\"https://ethereum.org\"" {
- t.Errorf("expected: %v, got: %v", "\"https://ethereum.org\"", string(json))
- }
-}
-
-func TestURLUnmarshalJSON(t *testing.T) {
- t.Parallel()
- url := &URL{}
- err := url.UnmarshalJSON([]byte("\"https://ethereum.org\""))
- if err != nil {
- t.Errorf("unexpected error: %v", err)
- }
- if url.Scheme != "https" {
- t.Errorf("expected: %v, got: %v", "https", url.Scheme)
- }
- if url.Path != "ethereum.org" {
- t.Errorf("expected: %v, got: %v", "https", url.Path)
- }
-}
-
-func TestURLComparison(t *testing.T) {
- t.Parallel()
- tests := []struct {
- urlA URL
- urlB URL
- expect int
- }{
- {URL{"https", "ethereum.org"}, URL{"https", "ethereum.org"}, 0},
- {URL{"http", "ethereum.org"}, URL{"https", "ethereum.org"}, -1},
- {URL{"https", "ethereum.org/a"}, URL{"https", "ethereum.org"}, 1},
- {URL{"https", "abc.org"}, URL{"https", "ethereum.org"}, -1},
- }
-
- for i, tt := range tests {
- result := tt.urlA.Cmp(tt.urlB)
- if result != tt.expect {
- t.Errorf("test %d: cmp mismatch: expected: %d, got: %d", i, tt.expect, result)
- }
- }
-}
diff --git a/accounts/usbwallet/hub.go b/accounts/usbwallet/hub.go
deleted file mode 100644
index e67942dbc1..0000000000
--- a/accounts/usbwallet/hub.go
+++ /dev/null
@@ -1,289 +0,0 @@
-// 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 usbwallet
-
-import (
- "errors"
- "runtime"
- "sync"
- "sync/atomic"
- "time"
-
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/log"
- "github.com/karalabe/usb"
-)
-
-// LedgerScheme is the protocol scheme prefixing account and wallet URLs.
-const LedgerScheme = "ledger"
-
-// TrezorScheme is the protocol scheme prefixing account and wallet URLs.
-const TrezorScheme = "trezor"
-
-// refreshCycle is the maximum time between wallet refreshes (if USB hotplug
-// notifications don't work).
-const refreshCycle = time.Second
-
-// refreshThrottling is the minimum time between wallet refreshes to avoid USB
-// trashing.
-const refreshThrottling = 500 * time.Millisecond
-
-// Hub is a accounts.Backend that can find and handle generic USB hardware wallets.
-type Hub struct {
- scheme string // Protocol scheme prefixing account and wallet URLs.
- vendorID uint16 // USB vendor identifier used for device discovery
- productIDs []uint16 // USB product identifiers used for device discovery
- usageID uint16 // USB usage page identifier used for macOS device discovery
- endpointID int // USB endpoint identifier used for non-macOS device discovery
- makeDriver func(log.Logger) driver // Factory method to construct a vendor specific driver
-
- refreshed time.Time // Time instance when the list of wallets was last refreshed
- wallets []accounts.Wallet // List of USB wallet devices currently tracking
- updateFeed event.Feed // Event feed to notify wallet additions/removals
- updateScope event.SubscriptionScope // Subscription scope tracking current live listeners
- updating bool // Whether the event notification loop is running
-
- quit chan chan error
-
- stateLock sync.RWMutex // Protects the internals of the hub from racey access
-
- // TODO(karalabe): remove if hotplug lands on Windows
- commsPend int // Number of operations blocking enumeration
- commsLock sync.Mutex // Lock protecting the pending counter and enumeration
- enumFails atomic.Uint32 // Number of times enumeration has failed
-}
-
-// NewLedgerHub creates a new hardware wallet manager for Ledger devices.
-func NewLedgerHub() (*Hub, error) {
- return newHub(LedgerScheme, 0x2c97, []uint16{
-
- // Device definitions taken from
- // https://github.com/LedgerHQ/ledger-live/blob/38012bc8899e0f07149ea9cfe7e64b2c146bc92b/libs/ledgerjs/packages/devices/src/index.ts
-
- // Original product IDs
- 0x0000, /* Ledger Blue */
- 0x0001, /* Ledger Nano S */
- 0x0004, /* Ledger Nano X */
- 0x0005, /* Ledger Nano S Plus */
- 0x0006, /* Ledger Nano FTS */
-
- 0x0015, /* HID + U2F + WebUSB Ledger Blue */
- 0x1015, /* HID + U2F + WebUSB Ledger Nano S */
- 0x4015, /* HID + U2F + WebUSB Ledger Nano X */
- 0x5015, /* HID + U2F + WebUSB Ledger Nano S Plus */
- 0x6015, /* HID + U2F + WebUSB Ledger Nano FTS */
-
- 0x0011, /* HID + WebUSB Ledger Blue */
- 0x1011, /* HID + WebUSB Ledger Nano S */
- 0x4011, /* HID + WebUSB Ledger Nano X */
- 0x5011, /* HID + WebUSB Ledger Nano S Plus */
- 0x6011, /* HID + WebUSB Ledger Nano FTS */
- }, 0xffa0, 0, newLedgerDriver)
-}
-
-// NewTrezorHubWithHID creates a new hardware wallet manager for Trezor devices.
-func NewTrezorHubWithHID() (*Hub, error) {
- return newHub(TrezorScheme, 0x534c, []uint16{0x0001 /* Trezor HID */}, 0xff00, 0, newTrezorDriver)
-}
-
-// NewTrezorHubWithWebUSB creates a new hardware wallet manager for Trezor devices with
-// firmware version > 1.8.0
-func NewTrezorHubWithWebUSB() (*Hub, error) {
- return newHub(TrezorScheme, 0x1209, []uint16{0x53c1 /* Trezor WebUSB */}, 0xffff /* No usage id on webusb, don't match unset (0) */, 0, newTrezorDriver)
-}
-
-// newHub creates a new hardware wallet manager for generic USB devices.
-func newHub(scheme string, vendorID uint16, productIDs []uint16, usageID uint16, endpointID int, makeDriver func(log.Logger) driver) (*Hub, error) {
- if !usb.Supported() {
- return nil, errors.New("unsupported platform")
- }
- hub := &Hub{
- scheme: scheme,
- vendorID: vendorID,
- productIDs: productIDs,
- usageID: usageID,
- endpointID: endpointID,
- makeDriver: makeDriver,
- quit: make(chan chan error),
- }
- hub.refreshWallets()
- return hub, nil
-}
-
-// Wallets implements accounts.Backend, returning all the currently tracked USB
-// devices that appear to be hardware wallets.
-func (hub *Hub) Wallets() []accounts.Wallet {
- // Make sure the list of wallets is up to date
- hub.refreshWallets()
-
- hub.stateLock.RLock()
- defer hub.stateLock.RUnlock()
-
- cpy := make([]accounts.Wallet, len(hub.wallets))
- copy(cpy, hub.wallets)
- return cpy
-}
-
-// refreshWallets scans the USB devices attached to the machine and updates the
-// list of wallets based on the found devices.
-func (hub *Hub) refreshWallets() {
- // Don't scan the USB like crazy it the user fetches wallets in a loop
- hub.stateLock.RLock()
- elapsed := time.Since(hub.refreshed)
- hub.stateLock.RUnlock()
-
- if elapsed < refreshThrottling {
- return
- }
- // If USB enumeration is continually failing, don't keep trying indefinitely
- if hub.enumFails.Load() > 2 {
- return
- }
- // Retrieve the current list of USB wallet devices
- var devices []usb.DeviceInfo
-
- if runtime.GOOS == "linux" {
- // hidapi on Linux opens the device during enumeration to retrieve some infos,
- // breaking the Ledger protocol if that is waiting for user confirmation. This
- // is a bug acknowledged at Ledger, but it won't be fixed on old devices so we
- // need to prevent concurrent comms ourselves. The more elegant solution would
- // be to ditch enumeration in favor of hotplug events, but that don't work yet
- // on Windows so if we need to hack it anyway, this is more elegant for now.
- hub.commsLock.Lock()
- if hub.commsPend > 0 { // A confirmation is pending, don't refresh
- hub.commsLock.Unlock()
- return
- }
- }
- infos, err := usb.Enumerate(hub.vendorID, 0)
- if err != nil {
- failcount := hub.enumFails.Add(1)
- if runtime.GOOS == "linux" {
- // See rationale before the enumeration why this is needed and only on Linux.
- hub.commsLock.Unlock()
- }
- log.Error("Failed to enumerate USB devices", "hub", hub.scheme,
- "vendor", hub.vendorID, "failcount", failcount, "err", err)
- return
- }
- hub.enumFails.Store(0)
-
- for _, info := range infos {
- for _, id := range hub.productIDs {
- // Windows and Macos use UsageID matching, Linux uses Interface matching
- if info.ProductID == id && (info.UsagePage == hub.usageID || info.Interface == hub.endpointID) {
- devices = append(devices, info)
- break
- }
- }
- }
- if runtime.GOOS == "linux" {
- // See rationale before the enumeration why this is needed and only on Linux.
- hub.commsLock.Unlock()
- }
- // Transform the current list of wallets into the new one
- hub.stateLock.Lock()
-
- var (
- wallets = make([]accounts.Wallet, 0, len(devices))
- events []accounts.WalletEvent
- )
-
- for _, device := range devices {
- url := accounts.URL{Scheme: hub.scheme, Path: device.Path}
-
- // Drop wallets in front of the next device or those that failed for some reason
- for len(hub.wallets) > 0 {
- // Abort if we're past the current device and found an operational one
- _, failure := hub.wallets[0].Status()
- if hub.wallets[0].URL().Cmp(url) >= 0 || failure == nil {
- break
- }
- // Drop the stale and failed devices
- events = append(events, accounts.WalletEvent{Wallet: hub.wallets[0], Kind: accounts.WalletDropped})
- hub.wallets = hub.wallets[1:]
- }
- // If there are no more wallets or the device is before the next, wrap new wallet
- if len(hub.wallets) == 0 || hub.wallets[0].URL().Cmp(url) > 0 {
- logger := log.New("url", url)
- wallet := &wallet{hub: hub, driver: hub.makeDriver(logger), url: &url, info: device, log: logger}
-
- events = append(events, accounts.WalletEvent{Wallet: wallet, Kind: accounts.WalletArrived})
- wallets = append(wallets, wallet)
- continue
- }
- // If the device is the same as the first wallet, keep it
- if hub.wallets[0].URL().Cmp(url) == 0 {
- wallets = append(wallets, hub.wallets[0])
- hub.wallets = hub.wallets[1:]
- continue
- }
- }
- // Drop any leftover wallets and set the new batch
- for _, wallet := range hub.wallets {
- events = append(events, accounts.WalletEvent{Wallet: wallet, Kind: accounts.WalletDropped})
- }
- hub.refreshed = time.Now()
- hub.wallets = wallets
- hub.stateLock.Unlock()
-
- // Fire all wallet events and return
- for _, event := range events {
- hub.updateFeed.Send(event)
- }
-}
-
-// Subscribe implements accounts.Backend, creating an async subscription to
-// receive notifications on the addition or removal of USB wallets.
-func (hub *Hub) Subscribe(sink chan<- accounts.WalletEvent) event.Subscription {
- // We need the mutex to reliably start/stop the update loop
- hub.stateLock.Lock()
- defer hub.stateLock.Unlock()
-
- // Subscribe the caller and track the subscriber count
- sub := hub.updateScope.Track(hub.updateFeed.Subscribe(sink))
-
- // Subscribers require an active notification loop, start it
- if !hub.updating {
- hub.updating = true
- go hub.updater()
- }
- return sub
-}
-
-// updater is responsible for maintaining an up-to-date list of wallets managed
-// by the USB hub, and for firing wallet addition/removal events.
-func (hub *Hub) updater() {
- for {
- // TODO: Wait for a USB hotplug event (not supported yet) or a refresh timeout
- // <-hub.changes
- time.Sleep(refreshCycle)
-
- // Run the wallet refresher
- hub.refreshWallets()
-
- // If all our subscribers left, stop the updater
- hub.stateLock.Lock()
- if hub.updateScope.Count() == 0 {
- hub.updating = false
- hub.stateLock.Unlock()
- return
- }
- hub.stateLock.Unlock()
- }
-}
diff --git a/accounts/usbwallet/ledger.go b/accounts/usbwallet/ledger.go
deleted file mode 100644
index 723df0f2b3..0000000000
--- a/accounts/usbwallet/ledger.go
+++ /dev/null
@@ -1,554 +0,0 @@
-// 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 .
-
-// This file contains the implementation for interacting with the Ledger hardware
-// wallets. The wire protocol spec can be found in the Ledger Blue GitHub repo:
-// https://raw.githubusercontent.com/LedgerHQ/blue-app-eth/master/doc/ethapp.asc
-
-package usbwallet
-
-import (
- "encoding/binary"
- "encoding/hex"
- "errors"
- "fmt"
- "io"
- "math/big"
-
- "github.com/ethereum/go-ethereum/accounts"
- "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/log"
- "github.com/ethereum/go-ethereum/rlp"
-)
-
-// ledgerOpcode is an enumeration encoding the supported Ledger opcodes.
-type ledgerOpcode byte
-
-// ledgerParam1 is an enumeration encoding the supported Ledger parameters for
-// specific opcodes. The same parameter values may be reused between opcodes.
-type ledgerParam1 byte
-
-// ledgerParam2 is an enumeration encoding the supported Ledger parameters for
-// specific opcodes. The same parameter values may be reused between opcodes.
-type ledgerParam2 byte
-
-const (
- ledgerOpRetrieveAddress ledgerOpcode = 0x02 // Returns the public key and Ethereum address for a given BIP 32 path
- ledgerOpSignTransaction ledgerOpcode = 0x04 // Signs an Ethereum transaction after having the user validate the parameters
- ledgerOpGetConfiguration ledgerOpcode = 0x06 // Returns specific wallet application configuration
- ledgerOpSignTypedMessage ledgerOpcode = 0x0c // Signs an Ethereum message following the EIP 712 specification
-
- ledgerP1DirectlyFetchAddress ledgerParam1 = 0x00 // Return address directly from the wallet
- ledgerP1InitTypedMessageData ledgerParam1 = 0x00 // First chunk of Typed Message data
- ledgerP1InitTransactionData ledgerParam1 = 0x00 // First transaction data block for signing
- ledgerP1ContTransactionData ledgerParam1 = 0x80 // Subsequent transaction data block for signing
- ledgerP2DiscardAddressChainCode ledgerParam2 = 0x00 // Do not return the chain code along with the address
-
- ledgerEip155Size int = 3 // Size of the EIP-155 chain_id,r,s in unsigned transactions
-)
-
-// errLedgerReplyInvalidHeader is the error message returned by a Ledger data exchange
-// if the device replies with a mismatching header. This usually means the device
-// is in browser mode.
-var errLedgerReplyInvalidHeader = errors.New("ledger: invalid reply header")
-
-// errLedgerInvalidVersionReply is the error message returned by a Ledger version retrieval
-// when a response does arrive, but it does not contain the expected data.
-var errLedgerInvalidVersionReply = errors.New("ledger: invalid version reply")
-
-// ledgerDriver implements the communication with a Ledger hardware wallet.
-type ledgerDriver struct {
- device io.ReadWriter // USB device connection to communicate through
- version [3]byte // Current version of the Ledger firmware (zero if app is offline)
- browser bool // Flag whether the Ledger is in browser mode (reply channel mismatch)
- failure error // Any failure that would make the device unusable
- log log.Logger // Contextual logger to tag the ledger with its id
-}
-
-// newLedgerDriver creates a new instance of a Ledger USB protocol driver.
-func newLedgerDriver(logger log.Logger) driver {
- return &ledgerDriver{
- log: logger,
- }
-}
-
-// Status implements usbwallet.driver, returning various states the Ledger can
-// currently be in.
-func (w *ledgerDriver) Status() (string, error) {
- if w.failure != nil {
- return fmt.Sprintf("Failed: %v", w.failure), w.failure
- }
- if w.browser {
- return "Ethereum app in browser mode", w.failure
- }
- if w.offline() {
- return "Ethereum app offline", w.failure
- }
- return fmt.Sprintf("Ethereum app v%d.%d.%d online", w.version[0], w.version[1], w.version[2]), w.failure
-}
-
-// offline returns whether the wallet and the Ethereum app is offline or not.
-//
-// The method assumes that the state lock is held!
-func (w *ledgerDriver) offline() bool {
- return w.version == [3]byte{0, 0, 0}
-}
-
-// Open implements usbwallet.driver, attempting to initialize the connection to the
-// Ledger hardware wallet. The Ledger does not require a user passphrase, so that
-// parameter is silently discarded.
-func (w *ledgerDriver) Open(device io.ReadWriter, passphrase string) error {
- w.device, w.failure = device, nil
-
- _, err := w.ledgerDerive(accounts.DefaultBaseDerivationPath)
- if err != nil {
- // Ethereum app is not running or in browser mode, nothing more to do, return
- if err == errLedgerReplyInvalidHeader {
- w.browser = true
- }
- return nil
- }
- // Try to resolve the Ethereum app's version, will fail prior to v1.0.2
- if w.version, err = w.ledgerVersion(); err != nil {
- w.version = [3]byte{1, 0, 0} // Assume worst case, can't verify if v1.0.0 or v1.0.1
- }
- return nil
-}
-
-// Close implements usbwallet.driver, cleaning up and metadata maintained within
-// the Ledger driver.
-func (w *ledgerDriver) Close() error {
- w.browser, w.version = false, [3]byte{}
- return nil
-}
-
-// Heartbeat implements usbwallet.driver, performing a sanity check against the
-// Ledger to see if it's still online.
-func (w *ledgerDriver) Heartbeat() error {
- if _, err := w.ledgerVersion(); err != nil && err != errLedgerInvalidVersionReply {
- w.failure = err
- return err
- }
- return nil
-}
-
-// Derive implements usbwallet.driver, sending a derivation request to the Ledger
-// and returning the Ethereum address located on that derivation path.
-func (w *ledgerDriver) Derive(path accounts.DerivationPath) (common.Address, error) {
- return w.ledgerDerive(path)
-}
-
-// SignTx implements usbwallet.driver, sending the transaction to the Ledger and
-// waiting for the user to confirm or deny the transaction.
-//
-// Note, if the version of the Ethereum application running on the Ledger wallet is
-// too old to sign EIP-155 transactions, but such is requested nonetheless, an error
-// will be returned opposed to silently signing in Homestead mode.
-func (w *ledgerDriver) SignTx(path accounts.DerivationPath, tx *types.Transaction, chainID *big.Int) (common.Address, *types.Transaction, error) {
- // If the Ethereum app doesn't run, abort
- if w.offline() {
- return common.Address{}, nil, accounts.ErrWalletClosed
- }
- // Ensure the wallet is capable of signing the given transaction
- if chainID != nil && w.version[0] <= 1 && w.version[1] <= 0 && w.version[2] <= 2 {
- //lint:ignore ST1005 brand name displayed on the console
- return common.Address{}, nil, fmt.Errorf("Ledger v%d.%d.%d doesn't support signing this transaction, please update to v1.0.3 at least", w.version[0], w.version[1], w.version[2])
- }
- // All infos gathered and metadata checks out, request signing
- return w.ledgerSign(path, tx, chainID)
-}
-
-// SignTypedMessage implements usbwallet.driver, sending the message to the Ledger and
-// waiting for the user to sign or deny the transaction.
-//
-// Note: this was introduced in the ledger 1.5.0 firmware
-func (w *ledgerDriver) SignTypedMessage(path accounts.DerivationPath, domainHash []byte, messageHash []byte) ([]byte, error) {
- // If the Ethereum app doesn't run, abort
- if w.offline() {
- return nil, accounts.ErrWalletClosed
- }
- // Ensure the wallet is capable of signing the given transaction
- if w.version[0] < 1 && w.version[1] < 5 {
- //lint:ignore ST1005 brand name displayed on the console
- return nil, fmt.Errorf("Ledger version >= 1.5.0 required for EIP-712 signing (found version v%d.%d.%d)", w.version[0], w.version[1], w.version[2])
- }
- // All infos gathered and metadata checks out, request signing
- return w.ledgerSignTypedMessage(path, domainHash, messageHash)
-}
-
-// ledgerVersion retrieves the current version of the Ethereum wallet app running
-// on the Ledger wallet.
-//
-// The version retrieval protocol is defined as follows:
-//
-// CLA | INS | P1 | P2 | Lc | Le
-// ----+-----+----+----+----+---
-// E0 | 06 | 00 | 00 | 00 | 04
-//
-// With no input data, and the output data being:
-//
-// Description | Length
-// ---------------------------------------------------+--------
-// Flags 01: arbitrary data signature enabled by user | 1 byte
-// Application major version | 1 byte
-// Application minor version | 1 byte
-// Application patch version | 1 byte
-func (w *ledgerDriver) ledgerVersion() ([3]byte, error) {
- // Send the request and wait for the response
- reply, err := w.ledgerExchange(ledgerOpGetConfiguration, 0, 0, nil)
- if err != nil {
- return [3]byte{}, err
- }
- if len(reply) != 4 {
- return [3]byte{}, errLedgerInvalidVersionReply
- }
- // Cache the version for future reference
- var version [3]byte
- copy(version[:], reply[1:])
- return version, nil
-}
-
-// ledgerDerive retrieves the currently active Ethereum address from a Ledger
-// wallet at the specified derivation path.
-//
-// The address derivation protocol is defined as follows:
-//
-// CLA | INS | P1 | P2 | Lc | Le
-// ----+-----+----+----+-----+---
-// E0 | 02 | 00 return address
-// 01 display address and confirm before returning
-// | 00: do not return the chain code
-// | 01: return the chain code
-// | var | 00
-//
-// Where the input data is:
-//
-// Description | Length
-// -------------------------------------------------+--------
-// Number of BIP 32 derivations to perform (max 10) | 1 byte
-// First derivation index (big endian) | 4 bytes
-// ... | 4 bytes
-// Last derivation index (big endian) | 4 bytes
-//
-// And the output data is:
-//
-// Description | Length
-// ------------------------+-------------------
-// Public Key length | 1 byte
-// Uncompressed Public Key | arbitrary
-// Ethereum address length | 1 byte
-// Ethereum address | 40 bytes hex ascii
-// Chain code if requested | 32 bytes
-func (w *ledgerDriver) ledgerDerive(derivationPath []uint32) (common.Address, error) {
- // Flatten the derivation path into the Ledger request
- path := make([]byte, 1+4*len(derivationPath))
- path[0] = byte(len(derivationPath))
- for i, component := range derivationPath {
- binary.BigEndian.PutUint32(path[1+4*i:], component)
- }
- // Send the request and wait for the response
- reply, err := w.ledgerExchange(ledgerOpRetrieveAddress, ledgerP1DirectlyFetchAddress, ledgerP2DiscardAddressChainCode, path)
- if err != nil {
- return common.Address{}, err
- }
- // Discard the public key, we don't need that for now
- if len(reply) < 1 || len(reply) < 1+int(reply[0]) {
- return common.Address{}, errors.New("reply lacks public key entry")
- }
- reply = reply[1+int(reply[0]):]
-
- // Extract the Ethereum hex address string
- if len(reply) < 1 || len(reply) < 1+int(reply[0]) {
- return common.Address{}, errors.New("reply lacks address entry")
- }
- hexstr := reply[1 : 1+int(reply[0])]
-
- // Decode the hex sting into an Ethereum address and return
- var address common.Address
- if _, err = hex.Decode(address[:], hexstr); err != nil {
- return common.Address{}, err
- }
- return address, nil
-}
-
-// ledgerSign sends the transaction to the Ledger wallet, and waits for the user
-// to confirm or deny the transaction.
-//
-// The transaction signing protocol is defined as follows:
-//
-// CLA | INS | P1 | P2 | Lc | Le
-// ----+-----+----+----+-----+---
-// E0 | 04 | 00: first transaction data block
-// 80: subsequent transaction data block
-// | 00 | variable | variable
-//
-// Where the input for the first transaction block (first 255 bytes) is:
-//
-// Description | Length
-// -------------------------------------------------+----------
-// Number of BIP 32 derivations to perform (max 10) | 1 byte
-// First derivation index (big endian) | 4 bytes
-// ... | 4 bytes
-// Last derivation index (big endian) | 4 bytes
-// RLP transaction chunk | arbitrary
-//
-// And the input for subsequent transaction blocks (first 255 bytes) are:
-//
-// Description | Length
-// ----------------------+----------
-// RLP transaction chunk | arbitrary
-//
-// And the output data is:
-//
-// Description | Length
-// ------------+---------
-// signature V | 1 byte
-// signature R | 32 bytes
-// signature S | 32 bytes
-func (w *ledgerDriver) ledgerSign(derivationPath []uint32, tx *types.Transaction, chainID *big.Int) (common.Address, *types.Transaction, error) {
- // Flatten the derivation path into the Ledger request
- path := make([]byte, 1+4*len(derivationPath))
- path[0] = byte(len(derivationPath))
- for i, component := range derivationPath {
- binary.BigEndian.PutUint32(path[1+4*i:], component)
- }
- // Create the transaction RLP based on whether legacy or EIP155 signing was requested
- var (
- txrlp []byte
- err error
- )
- if chainID == nil {
- if txrlp, err = rlp.EncodeToBytes([]interface{}{tx.Nonce(), tx.GasPrice(), tx.Gas(), tx.To(), tx.Value(), tx.Data()}); err != nil {
- return common.Address{}, nil, err
- }
- } else {
- if txrlp, err = rlp.EncodeToBytes([]interface{}{tx.Nonce(), tx.GasPrice(), tx.Gas(), tx.To(), tx.Value(), tx.Data(), chainID, big.NewInt(0), big.NewInt(0)}); err != nil {
- return common.Address{}, nil, err
- }
- }
- payload := append(path, txrlp...)
-
- // Send the request and wait for the response
- var (
- op = ledgerP1InitTransactionData
- reply []byte
- )
-
- // Chunk size selection to mitigate an underlying RLP deserialization issue on the ledger app.
- // https://github.com/LedgerHQ/app-ethereum/issues/409
- chunk := 255
- for ; len(payload)%chunk <= ledgerEip155Size; chunk-- {
- }
-
- for len(payload) > 0 {
- // Calculate the size of the next data chunk
- if chunk > len(payload) {
- chunk = len(payload)
- }
- // Send the chunk over, ensuring it's processed correctly
- reply, err = w.ledgerExchange(ledgerOpSignTransaction, op, 0, payload[:chunk])
- if err != nil {
- return common.Address{}, nil, err
- }
- // Shift the payload and ensure subsequent chunks are marked as such
- payload = payload[chunk:]
- op = ledgerP1ContTransactionData
- }
- // Extract the Ethereum signature and do a sanity validation
- if len(reply) != crypto.SignatureLength {
- return common.Address{}, nil, errors.New("reply lacks signature")
- }
- signature := append(reply[1:], reply[0])
-
- // Create the correct signer and signature transform based on the chain ID
- var signer types.Signer
- if chainID == nil {
- signer = new(types.HomesteadSigner)
- } else {
- signer = types.NewEIP155Signer(chainID)
- signature[64] -= byte(chainID.Uint64()*2 + 35)
- }
- signed, err := tx.WithSignature(signer, signature)
- if err != nil {
- return common.Address{}, nil, err
- }
- sender, err := types.Sender(signer, signed)
- if err != nil {
- return common.Address{}, nil, err
- }
- return sender, signed, nil
-}
-
-// ledgerSignTypedMessage sends the transaction to the Ledger wallet, and waits for the user
-// to confirm or deny the transaction.
-//
-// The signing protocol is defined as follows:
-//
-// CLA | INS | P1 | P2 | Lc | Le
-// ----+-----+----+-----------------------------+-----+---
-// E0 | 0C | 00 | implementation version : 00 | variable | variable
-//
-// Where the input is:
-//
-// Description | Length
-// -------------------------------------------------+----------
-// Number of BIP 32 derivations to perform (max 10) | 1 byte
-// First derivation index (big endian) | 4 bytes
-// ... | 4 bytes
-// Last derivation index (big endian) | 4 bytes
-// domain hash | 32 bytes
-// message hash | 32 bytes
-//
-// And the output data is:
-//
-// Description | Length
-// ------------+---------
-// signature V | 1 byte
-// signature R | 32 bytes
-// signature S | 32 bytes
-func (w *ledgerDriver) ledgerSignTypedMessage(derivationPath []uint32, domainHash []byte, messageHash []byte) ([]byte, error) {
- // Flatten the derivation path into the Ledger request
- path := make([]byte, 1+4*len(derivationPath))
- path[0] = byte(len(derivationPath))
- for i, component := range derivationPath {
- binary.BigEndian.PutUint32(path[1+4*i:], component)
- }
- // Create the 712 message
- payload := append(path, domainHash...)
- payload = append(payload, messageHash...)
-
- // Send the request and wait for the response
- var (
- op = ledgerP1InitTypedMessageData
- reply []byte
- err error
- )
-
- // Send the message over, ensuring it's processed correctly
- reply, err = w.ledgerExchange(ledgerOpSignTypedMessage, op, 0, payload)
-
- if err != nil {
- return nil, err
- }
-
- // Extract the Ethereum signature and do a sanity validation
- if len(reply) != crypto.SignatureLength {
- return nil, errors.New("reply lacks signature")
- }
- signature := append(reply[1:], reply[0])
- return signature, nil
-}
-
-// ledgerExchange performs a data exchange with the Ledger wallet, sending it a
-// message and retrieving the response.
-//
-// The common transport header is defined as follows:
-//
-// Description | Length
-// --------------------------------------+----------
-// Communication channel ID (big endian) | 2 bytes
-// Command tag | 1 byte
-// Packet sequence index (big endian) | 2 bytes
-// Payload | arbitrary
-//
-// The Communication channel ID allows commands multiplexing over the same
-// physical link. It is not used for the time being, and should be set to 0101
-// to avoid compatibility issues with implementations ignoring a leading 00 byte.
-//
-// The Command tag describes the message content. Use TAG_APDU (0x05) for standard
-// APDU payloads, or TAG_PING (0x02) for a simple link test.
-//
-// The Packet sequence index describes the current sequence for fragmented payloads.
-// The first fragment index is 0x00.
-//
-// APDU Command payloads are encoded as follows:
-//
-// Description | Length
-// -----------------------------------
-// APDU length (big endian) | 2 bytes
-// APDU CLA | 1 byte
-// APDU INS | 1 byte
-// APDU P1 | 1 byte
-// APDU P2 | 1 byte
-// APDU length | 1 byte
-// Optional APDU data | arbitrary
-func (w *ledgerDriver) ledgerExchange(opcode ledgerOpcode, p1 ledgerParam1, p2 ledgerParam2, data []byte) ([]byte, error) {
- // Construct the message payload, possibly split into multiple chunks
- apdu := make([]byte, 2, 7+len(data))
-
- binary.BigEndian.PutUint16(apdu, uint16(5+len(data)))
- apdu = append(apdu, []byte{0xe0, byte(opcode), byte(p1), byte(p2), byte(len(data))}...)
- apdu = append(apdu, data...)
-
- // Stream all the chunks to the device
- header := []byte{0x01, 0x01, 0x05, 0x00, 0x00} // Channel ID and command tag appended
- chunk := make([]byte, 64)
- space := len(chunk) - len(header)
-
- for i := 0; len(apdu) > 0; i++ {
- // Construct the new message to stream
- chunk = append(chunk[:0], header...)
- binary.BigEndian.PutUint16(chunk[3:], uint16(i))
-
- if len(apdu) > space {
- chunk = append(chunk, apdu[:space]...)
- apdu = apdu[space:]
- } else {
- chunk = append(chunk, apdu...)
- apdu = nil
- }
- // Send over to the device
- w.log.Trace("Data chunk sent to the Ledger", "chunk", hexutil.Bytes(chunk))
- if _, err := w.device.Write(chunk); err != nil {
- return nil, err
- }
- }
- // Stream the reply back from the wallet in 64 byte chunks
- var reply []byte
- chunk = chunk[:64] // Yeah, we surely have enough space
- for {
- // Read the next chunk from the Ledger wallet
- if _, err := io.ReadFull(w.device, chunk); err != nil {
- return nil, err
- }
- w.log.Trace("Data chunk received from the Ledger", "chunk", hexutil.Bytes(chunk))
-
- // Make sure the transport header matches
- if chunk[0] != 0x01 || chunk[1] != 0x01 || chunk[2] != 0x05 {
- return nil, errLedgerReplyInvalidHeader
- }
- // If it's the first chunk, retrieve the total message length
- var payload []byte
-
- if chunk[3] == 0x00 && chunk[4] == 0x00 {
- reply = make([]byte, 0, int(binary.BigEndian.Uint16(chunk[5:7])))
- payload = chunk[7:]
- } else {
- payload = chunk[5:]
- }
- // Append to the reply and stop when filled up
- if left := cap(reply) - len(reply); left > len(payload) {
- reply = append(reply, payload...)
- } else {
- reply = append(reply, payload[:left]...)
- break
- }
- }
- return reply[:len(reply)-2], nil
-}
diff --git a/accounts/usbwallet/trezor.go b/accounts/usbwallet/trezor.go
deleted file mode 100644
index 9644dc4e02..0000000000
--- a/accounts/usbwallet/trezor.go
+++ /dev/null
@@ -1,371 +0,0 @@
-// 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 .
-
-// This file contains the implementation for interacting with the Trezor hardware
-// wallets. The wire protocol spec can be found on the SatoshiLabs website:
-// https://doc.satoshilabs.com/trezor-tech/api-protobuf.html
-
-package usbwallet
-
-import (
- "encoding/binary"
- "errors"
- "fmt"
- "io"
- "math/big"
-
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/accounts/usbwallet/trezor"
- "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/log"
- "github.com/golang/protobuf/proto"
-)
-
-// ErrTrezorPINNeeded is returned if opening the trezor requires a PIN code. In
-// this case, the calling application should display a pinpad and send back the
-// encoded passphrase.
-var ErrTrezorPINNeeded = errors.New("trezor: pin needed")
-
-// ErrTrezorPassphraseNeeded is returned if opening the trezor requires a passphrase
-var ErrTrezorPassphraseNeeded = errors.New("trezor: passphrase needed")
-
-// errTrezorReplyInvalidHeader is the error message returned by a Trezor data exchange
-// if the device replies with a mismatching header. This usually means the device
-// is in browser mode.
-var errTrezorReplyInvalidHeader = errors.New("trezor: invalid reply header")
-
-// trezorDriver implements the communication with a Trezor hardware wallet.
-type trezorDriver struct {
- device io.ReadWriter // USB device connection to communicate through
- version [3]uint32 // Current version of the Trezor firmware
- label string // Current textual label of the Trezor device
- pinwait bool // Flags whether the device is waiting for PIN entry
- passphrasewait bool // Flags whether the device is waiting for passphrase entry
- failure error // Any failure that would make the device unusable
- log log.Logger // Contextual logger to tag the trezor with its id
-}
-
-// newTrezorDriver creates a new instance of a Trezor USB protocol driver.
-func newTrezorDriver(logger log.Logger) driver {
- return &trezorDriver{
- log: logger,
- }
-}
-
-// Status implements accounts.Wallet, always whether the Trezor is opened, closed
-// or whether the Ethereum app was not started on it.
-func (w *trezorDriver) Status() (string, error) {
- if w.failure != nil {
- return fmt.Sprintf("Failed: %v", w.failure), w.failure
- }
- if w.device == nil {
- return "Closed", w.failure
- }
- if w.pinwait {
- return fmt.Sprintf("Trezor v%d.%d.%d '%s' waiting for PIN", w.version[0], w.version[1], w.version[2], w.label), w.failure
- }
- return fmt.Sprintf("Trezor v%d.%d.%d '%s' online", w.version[0], w.version[1], w.version[2], w.label), w.failure
-}
-
-// Open implements usbwallet.driver, attempting to initialize the connection to
-// the Trezor hardware wallet. Initializing the Trezor is a two or three phase operation:
-// - The first phase is to initialize the connection and read the wallet's
-// features. This phase is invoked if the provided passphrase is empty. The
-// device will display the pinpad as a result and will return an appropriate
-// error to notify the user that a second open phase is needed.
-// - The second phase is to unlock access to the Trezor, which is done by the
-// user actually providing a passphrase mapping a keyboard keypad to the pin
-// number of the user (shuffled according to the pinpad displayed).
-// - If needed the device will ask for passphrase which will require calling
-// open again with the actual passphrase (3rd phase)
-func (w *trezorDriver) Open(device io.ReadWriter, passphrase string) error {
- w.device, w.failure = device, nil
-
- // If phase 1 is requested, init the connection and wait for user callback
- if passphrase == "" && !w.passphrasewait {
- // If we're already waiting for a PIN entry, insta-return
- if w.pinwait {
- return ErrTrezorPINNeeded
- }
- // Initialize a connection to the device
- features := new(trezor.Features)
- if _, err := w.trezorExchange(&trezor.Initialize{}, features); err != nil {
- return err
- }
- w.version = [3]uint32{features.GetMajorVersion(), features.GetMinorVersion(), features.GetPatchVersion()}
- w.label = features.GetLabel()
-
- // Do a manual ping, forcing the device to ask for its PIN and Passphrase
- askPin := true
- askPassphrase := true
- res, err := w.trezorExchange(&trezor.Ping{PinProtection: &askPin, PassphraseProtection: &askPassphrase}, new(trezor.PinMatrixRequest), new(trezor.PassphraseRequest), new(trezor.Success))
- if err != nil {
- return err
- }
- // Only return the PIN request if the device wasn't unlocked until now
- switch res {
- case 0:
- w.pinwait = true
- return ErrTrezorPINNeeded
- case 1:
- w.pinwait = false
- w.passphrasewait = true
- return ErrTrezorPassphraseNeeded
- case 2:
- return nil // responded with trezor.Success
- }
- }
- // Phase 2 requested with actual PIN entry
- if w.pinwait {
- w.pinwait = false
- res, err := w.trezorExchange(&trezor.PinMatrixAck{Pin: &passphrase}, new(trezor.Success), new(trezor.PassphraseRequest))
- if err != nil {
- w.failure = err
- return err
- }
- if res == 1 {
- w.passphrasewait = true
- return ErrTrezorPassphraseNeeded
- }
- } else if w.passphrasewait {
- w.passphrasewait = false
- if _, err := w.trezorExchange(&trezor.PassphraseAck{Passphrase: &passphrase}, new(trezor.Success)); err != nil {
- w.failure = err
- return err
- }
- }
-
- return nil
-}
-
-// Close implements usbwallet.driver, cleaning up and metadata maintained within
-// the Trezor driver.
-func (w *trezorDriver) Close() error {
- w.version, w.label, w.pinwait = [3]uint32{}, "", false
- return nil
-}
-
-// Heartbeat implements usbwallet.driver, performing a sanity check against the
-// Trezor to see if it's still online.
-func (w *trezorDriver) Heartbeat() error {
- if _, err := w.trezorExchange(&trezor.Ping{}, new(trezor.Success)); err != nil {
- w.failure = err
- return err
- }
- return nil
-}
-
-// Derive implements usbwallet.driver, sending a derivation request to the Trezor
-// and returning the Ethereum address located on that derivation path.
-func (w *trezorDriver) Derive(path accounts.DerivationPath) (common.Address, error) {
- return w.trezorDerive(path)
-}
-
-// SignTx implements usbwallet.driver, sending the transaction to the Trezor and
-// waiting for the user to confirm or deny the transaction.
-func (w *trezorDriver) SignTx(path accounts.DerivationPath, tx *types.Transaction, chainID *big.Int) (common.Address, *types.Transaction, error) {
- if w.device == nil {
- return common.Address{}, nil, accounts.ErrWalletClosed
- }
- return w.trezorSign(path, tx, chainID)
-}
-
-func (w *trezorDriver) SignTypedMessage(path accounts.DerivationPath, domainHash []byte, messageHash []byte) ([]byte, error) {
- return nil, accounts.ErrNotSupported
-}
-
-// trezorDerive sends a derivation request to the Trezor device and returns the
-// Ethereum address located on that path.
-func (w *trezorDriver) trezorDerive(derivationPath []uint32) (common.Address, error) {
- address := new(trezor.EthereumAddress)
- if _, err := w.trezorExchange(&trezor.EthereumGetAddress{AddressN: derivationPath}, address); err != nil {
- return common.Address{}, err
- }
- if addr := address.GetAddressBin(); len(addr) > 0 { // Older firmwares use binary formats
- return common.BytesToAddress(addr), nil
- }
- if addr := address.GetAddressHex(); len(addr) > 0 { // Newer firmwares use hexadecimal formats
- return common.HexToAddress(addr), nil
- }
- return common.Address{}, errors.New("missing derived address")
-}
-
-// trezorSign sends the transaction to the Trezor wallet, and waits for the user
-// to confirm or deny the transaction.
-func (w *trezorDriver) trezorSign(derivationPath []uint32, tx *types.Transaction, chainID *big.Int) (common.Address, *types.Transaction, error) {
- // Create the transaction initiation message
- data := tx.Data()
- length := uint32(len(data))
-
- request := &trezor.EthereumSignTx{
- AddressN: derivationPath,
- Nonce: new(big.Int).SetUint64(tx.Nonce()).Bytes(),
- GasPrice: tx.GasPrice().Bytes(),
- GasLimit: new(big.Int).SetUint64(tx.Gas()).Bytes(),
- Value: tx.Value().Bytes(),
- DataLength: &length,
- }
- if to := tx.To(); to != nil {
- // Non contract deploy, set recipient explicitly
- hex := to.Hex()
- request.ToHex = &hex // Newer firmwares (old will ignore)
- request.ToBin = (*to)[:] // Older firmwares (new will ignore)
- }
- if length > 1024 { // Send the data chunked if that was requested
- request.DataInitialChunk, data = data[:1024], data[1024:]
- } else {
- request.DataInitialChunk, data = data, nil
- }
- if chainID != nil { // EIP-155 transaction, set chain ID explicitly (only 32 bit is supported!?)
- id := uint32(chainID.Int64())
- request.ChainId = &id
- }
- // Send the initiation message and stream content until a signature is returned
- response := new(trezor.EthereumTxRequest)
- if _, err := w.trezorExchange(request, response); err != nil {
- return common.Address{}, nil, err
- }
- for response.DataLength != nil && int(*response.DataLength) <= len(data) {
- chunk := data[:*response.DataLength]
- data = data[*response.DataLength:]
-
- if _, err := w.trezorExchange(&trezor.EthereumTxAck{DataChunk: chunk}, response); err != nil {
- return common.Address{}, nil, err
- }
- }
- // Extract the Ethereum signature and do a sanity validation
- if len(response.GetSignatureR()) == 0 || len(response.GetSignatureS()) == 0 || response.GetSignatureV() == 0 {
- return common.Address{}, nil, errors.New("reply lacks signature")
- }
- signature := append(append(response.GetSignatureR(), response.GetSignatureS()...), byte(response.GetSignatureV()))
-
- // Create the correct signer and signature transform based on the chain ID
- var signer types.Signer
- if chainID == nil {
- signer = new(types.HomesteadSigner)
- } else {
- // Trezor backend does not support typed transactions yet.
- signer = types.NewEIP155Signer(chainID)
- signature[64] -= byte(chainID.Uint64()*2 + 35)
- }
-
- // Inject the final signature into the transaction and sanity check the sender
- signed, err := tx.WithSignature(signer, signature)
- if err != nil {
- return common.Address{}, nil, err
- }
- sender, err := types.Sender(signer, signed)
- if err != nil {
- return common.Address{}, nil, err
- }
- return sender, signed, nil
-}
-
-// trezorExchange performs a data exchange with the Trezor wallet, sending it a
-// message and retrieving the response. If multiple responses are possible, the
-// method will also return the index of the destination object used.
-func (w *trezorDriver) trezorExchange(req proto.Message, results ...proto.Message) (int, error) {
- // Construct the original message payload to chunk up
- data, err := proto.Marshal(req)
- if err != nil {
- return 0, err
- }
- payload := make([]byte, 8+len(data))
- copy(payload, []byte{0x23, 0x23})
- binary.BigEndian.PutUint16(payload[2:], trezor.Type(req))
- binary.BigEndian.PutUint32(payload[4:], uint32(len(data)))
- copy(payload[8:], data)
-
- // Stream all the chunks to the device
- chunk := make([]byte, 64)
- chunk[0] = 0x3f // Report ID magic number
-
- for len(payload) > 0 {
- // Construct the new message to stream, padding with zeroes if needed
- if len(payload) > 63 {
- copy(chunk[1:], payload[:63])
- payload = payload[63:]
- } else {
- copy(chunk[1:], payload)
- copy(chunk[1+len(payload):], make([]byte, 63-len(payload)))
- payload = nil
- }
- // Send over to the device
- w.log.Trace("Data chunk sent to the Trezor", "chunk", hexutil.Bytes(chunk))
- if _, err := w.device.Write(chunk); err != nil {
- return 0, err
- }
- }
- // Stream the reply back from the wallet in 64 byte chunks
- var (
- kind uint16
- reply []byte
- )
- for {
- // Read the next chunk from the Trezor wallet
- if _, err := io.ReadFull(w.device, chunk); err != nil {
- return 0, err
- }
- w.log.Trace("Data chunk received from the Trezor", "chunk", hexutil.Bytes(chunk))
-
- // Make sure the transport header matches
- if chunk[0] != 0x3f || (len(reply) == 0 && (chunk[1] != 0x23 || chunk[2] != 0x23)) {
- return 0, errTrezorReplyInvalidHeader
- }
- // If it's the first chunk, retrieve the reply message type and total message length
- var payload []byte
-
- if len(reply) == 0 {
- kind = binary.BigEndian.Uint16(chunk[3:5])
- reply = make([]byte, 0, int(binary.BigEndian.Uint32(chunk[5:9])))
- payload = chunk[9:]
- } else {
- payload = chunk[1:]
- }
- // Append to the reply and stop when filled up
- if left := cap(reply) - len(reply); left > len(payload) {
- reply = append(reply, payload...)
- } else {
- reply = append(reply, payload[:left]...)
- break
- }
- }
- // Try to parse the reply into the requested reply message
- if kind == uint16(trezor.MessageType_MessageType_Failure) {
- // Trezor returned a failure, extract and return the message
- failure := new(trezor.Failure)
- if err := proto.Unmarshal(reply, failure); err != nil {
- return 0, err
- }
- return 0, errors.New("trezor: " + failure.GetMessage())
- }
- if kind == uint16(trezor.MessageType_MessageType_ButtonRequest) {
- // Trezor is waiting for user confirmation, ack and wait for the next message
- return w.trezorExchange(&trezor.ButtonAck{}, results...)
- }
- for i, res := range results {
- if trezor.Type(res) == kind {
- return i, proto.Unmarshal(reply, res)
- }
- }
- expected := make([]string, len(results))
- for i, res := range results {
- expected[i] = trezor.Name(trezor.Type(res))
- }
- return 0, fmt.Errorf("trezor: expected reply types %s, got %s", expected, trezor.Name(kind))
-}
diff --git a/accounts/usbwallet/trezor/messages-common.pb.go b/accounts/usbwallet/trezor/messages-common.pb.go
deleted file mode 100644
index b396c6d8b5..0000000000
--- a/accounts/usbwallet/trezor/messages-common.pb.go
+++ /dev/null
@@ -1,811 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: messages-common.proto
-
-package trezor
-
-import (
- fmt "fmt"
- math "math"
-
- proto "github.com/golang/protobuf/proto"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
-
-type Failure_FailureType int32
-
-const (
- Failure_Failure_UnexpectedMessage Failure_FailureType = 1
- Failure_Failure_ButtonExpected Failure_FailureType = 2
- Failure_Failure_DataError Failure_FailureType = 3
- Failure_Failure_ActionCancelled Failure_FailureType = 4
- Failure_Failure_PinExpected Failure_FailureType = 5
- Failure_Failure_PinCancelled Failure_FailureType = 6
- Failure_Failure_PinInvalid Failure_FailureType = 7
- Failure_Failure_InvalidSignature Failure_FailureType = 8
- Failure_Failure_ProcessError Failure_FailureType = 9
- Failure_Failure_NotEnoughFunds Failure_FailureType = 10
- Failure_Failure_NotInitialized Failure_FailureType = 11
- Failure_Failure_PinMismatch Failure_FailureType = 12
- Failure_Failure_FirmwareError Failure_FailureType = 99
-)
-
-var Failure_FailureType_name = map[int32]string{
- 1: "Failure_UnexpectedMessage",
- 2: "Failure_ButtonExpected",
- 3: "Failure_DataError",
- 4: "Failure_ActionCancelled",
- 5: "Failure_PinExpected",
- 6: "Failure_PinCancelled",
- 7: "Failure_PinInvalid",
- 8: "Failure_InvalidSignature",
- 9: "Failure_ProcessError",
- 10: "Failure_NotEnoughFunds",
- 11: "Failure_NotInitialized",
- 12: "Failure_PinMismatch",
- 99: "Failure_FirmwareError",
-}
-
-var Failure_FailureType_value = map[string]int32{
- "Failure_UnexpectedMessage": 1,
- "Failure_ButtonExpected": 2,
- "Failure_DataError": 3,
- "Failure_ActionCancelled": 4,
- "Failure_PinExpected": 5,
- "Failure_PinCancelled": 6,
- "Failure_PinInvalid": 7,
- "Failure_InvalidSignature": 8,
- "Failure_ProcessError": 9,
- "Failure_NotEnoughFunds": 10,
- "Failure_NotInitialized": 11,
- "Failure_PinMismatch": 12,
- "Failure_FirmwareError": 99,
-}
-
-func (x Failure_FailureType) Enum() *Failure_FailureType {
- p := new(Failure_FailureType)
- *p = x
- return p
-}
-
-func (x Failure_FailureType) String() string {
- return proto.EnumName(Failure_FailureType_name, int32(x))
-}
-
-func (x *Failure_FailureType) UnmarshalJSON(data []byte) error {
- value, err := proto.UnmarshalJSONEnum(Failure_FailureType_value, data, "Failure_FailureType")
- if err != nil {
- return err
- }
- *x = Failure_FailureType(value)
- return nil
-}
-
-func (Failure_FailureType) EnumDescriptor() ([]byte, []int) {
- return fileDescriptor_aaf30d059fdbc38d, []int{1, 0}
-}
-
-// *
-// Type of button request
-type ButtonRequest_ButtonRequestType int32
-
-const (
- ButtonRequest_ButtonRequest_Other ButtonRequest_ButtonRequestType = 1
- ButtonRequest_ButtonRequest_FeeOverThreshold ButtonRequest_ButtonRequestType = 2
- ButtonRequest_ButtonRequest_ConfirmOutput ButtonRequest_ButtonRequestType = 3
- ButtonRequest_ButtonRequest_ResetDevice ButtonRequest_ButtonRequestType = 4
- ButtonRequest_ButtonRequest_ConfirmWord ButtonRequest_ButtonRequestType = 5
- ButtonRequest_ButtonRequest_WipeDevice ButtonRequest_ButtonRequestType = 6
- ButtonRequest_ButtonRequest_ProtectCall ButtonRequest_ButtonRequestType = 7
- ButtonRequest_ButtonRequest_SignTx ButtonRequest_ButtonRequestType = 8
- ButtonRequest_ButtonRequest_FirmwareCheck ButtonRequest_ButtonRequestType = 9
- ButtonRequest_ButtonRequest_Address ButtonRequest_ButtonRequestType = 10
- ButtonRequest_ButtonRequest_PublicKey ButtonRequest_ButtonRequestType = 11
- ButtonRequest_ButtonRequest_MnemonicWordCount ButtonRequest_ButtonRequestType = 12
- ButtonRequest_ButtonRequest_MnemonicInput ButtonRequest_ButtonRequestType = 13
- ButtonRequest_ButtonRequest_PassphraseType ButtonRequest_ButtonRequestType = 14
- ButtonRequest_ButtonRequest_UnknownDerivationPath ButtonRequest_ButtonRequestType = 15
-)
-
-var ButtonRequest_ButtonRequestType_name = map[int32]string{
- 1: "ButtonRequest_Other",
- 2: "ButtonRequest_FeeOverThreshold",
- 3: "ButtonRequest_ConfirmOutput",
- 4: "ButtonRequest_ResetDevice",
- 5: "ButtonRequest_ConfirmWord",
- 6: "ButtonRequest_WipeDevice",
- 7: "ButtonRequest_ProtectCall",
- 8: "ButtonRequest_SignTx",
- 9: "ButtonRequest_FirmwareCheck",
- 10: "ButtonRequest_Address",
- 11: "ButtonRequest_PublicKey",
- 12: "ButtonRequest_MnemonicWordCount",
- 13: "ButtonRequest_MnemonicInput",
- 14: "ButtonRequest_PassphraseType",
- 15: "ButtonRequest_UnknownDerivationPath",
-}
-
-var ButtonRequest_ButtonRequestType_value = map[string]int32{
- "ButtonRequest_Other": 1,
- "ButtonRequest_FeeOverThreshold": 2,
- "ButtonRequest_ConfirmOutput": 3,
- "ButtonRequest_ResetDevice": 4,
- "ButtonRequest_ConfirmWord": 5,
- "ButtonRequest_WipeDevice": 6,
- "ButtonRequest_ProtectCall": 7,
- "ButtonRequest_SignTx": 8,
- "ButtonRequest_FirmwareCheck": 9,
- "ButtonRequest_Address": 10,
- "ButtonRequest_PublicKey": 11,
- "ButtonRequest_MnemonicWordCount": 12,
- "ButtonRequest_MnemonicInput": 13,
- "ButtonRequest_PassphraseType": 14,
- "ButtonRequest_UnknownDerivationPath": 15,
-}
-
-func (x ButtonRequest_ButtonRequestType) Enum() *ButtonRequest_ButtonRequestType {
- p := new(ButtonRequest_ButtonRequestType)
- *p = x
- return p
-}
-
-func (x ButtonRequest_ButtonRequestType) String() string {
- return proto.EnumName(ButtonRequest_ButtonRequestType_name, int32(x))
-}
-
-func (x *ButtonRequest_ButtonRequestType) UnmarshalJSON(data []byte) error {
- value, err := proto.UnmarshalJSONEnum(ButtonRequest_ButtonRequestType_value, data, "ButtonRequest_ButtonRequestType")
- if err != nil {
- return err
- }
- *x = ButtonRequest_ButtonRequestType(value)
- return nil
-}
-
-func (ButtonRequest_ButtonRequestType) EnumDescriptor() ([]byte, []int) {
- return fileDescriptor_aaf30d059fdbc38d, []int{2, 0}
-}
-
-// *
-// Type of PIN request
-type PinMatrixRequest_PinMatrixRequestType int32
-
-const (
- PinMatrixRequest_PinMatrixRequestType_Current PinMatrixRequest_PinMatrixRequestType = 1
- PinMatrixRequest_PinMatrixRequestType_NewFirst PinMatrixRequest_PinMatrixRequestType = 2
- PinMatrixRequest_PinMatrixRequestType_NewSecond PinMatrixRequest_PinMatrixRequestType = 3
-)
-
-var PinMatrixRequest_PinMatrixRequestType_name = map[int32]string{
- 1: "PinMatrixRequestType_Current",
- 2: "PinMatrixRequestType_NewFirst",
- 3: "PinMatrixRequestType_NewSecond",
-}
-
-var PinMatrixRequest_PinMatrixRequestType_value = map[string]int32{
- "PinMatrixRequestType_Current": 1,
- "PinMatrixRequestType_NewFirst": 2,
- "PinMatrixRequestType_NewSecond": 3,
-}
-
-func (x PinMatrixRequest_PinMatrixRequestType) Enum() *PinMatrixRequest_PinMatrixRequestType {
- p := new(PinMatrixRequest_PinMatrixRequestType)
- *p = x
- return p
-}
-
-func (x PinMatrixRequest_PinMatrixRequestType) String() string {
- return proto.EnumName(PinMatrixRequest_PinMatrixRequestType_name, int32(x))
-}
-
-func (x *PinMatrixRequest_PinMatrixRequestType) UnmarshalJSON(data []byte) error {
- value, err := proto.UnmarshalJSONEnum(PinMatrixRequest_PinMatrixRequestType_value, data, "PinMatrixRequest_PinMatrixRequestType")
- if err != nil {
- return err
- }
- *x = PinMatrixRequest_PinMatrixRequestType(value)
- return nil
-}
-
-func (PinMatrixRequest_PinMatrixRequestType) EnumDescriptor() ([]byte, []int) {
- return fileDescriptor_aaf30d059fdbc38d, []int{4, 0}
-}
-
-// *
-// Response: Success of the previous request
-// @end
-type Success struct {
- Message *string `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Success) Reset() { *m = Success{} }
-func (m *Success) String() string { return proto.CompactTextString(m) }
-func (*Success) ProtoMessage() {}
-func (*Success) Descriptor() ([]byte, []int) {
- return fileDescriptor_aaf30d059fdbc38d, []int{0}
-}
-
-func (m *Success) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Success.Unmarshal(m, b)
-}
-func (m *Success) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Success.Marshal(b, m, deterministic)
-}
-func (m *Success) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Success.Merge(m, src)
-}
-func (m *Success) XXX_Size() int {
- return xxx_messageInfo_Success.Size(m)
-}
-func (m *Success) XXX_DiscardUnknown() {
- xxx_messageInfo_Success.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Success proto.InternalMessageInfo
-
-func (m *Success) GetMessage() string {
- if m != nil && m.Message != nil {
- return *m.Message
- }
- return ""
-}
-
-// *
-// Response: Failure of the previous request
-// @end
-type Failure struct {
- Code *Failure_FailureType `protobuf:"varint,1,opt,name=code,enum=hw.trezor.messages.common.Failure_FailureType" json:"code,omitempty"`
- Message *string `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Failure) Reset() { *m = Failure{} }
-func (m *Failure) String() string { return proto.CompactTextString(m) }
-func (*Failure) ProtoMessage() {}
-func (*Failure) Descriptor() ([]byte, []int) {
- return fileDescriptor_aaf30d059fdbc38d, []int{1}
-}
-
-func (m *Failure) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Failure.Unmarshal(m, b)
-}
-func (m *Failure) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Failure.Marshal(b, m, deterministic)
-}
-func (m *Failure) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Failure.Merge(m, src)
-}
-func (m *Failure) XXX_Size() int {
- return xxx_messageInfo_Failure.Size(m)
-}
-func (m *Failure) XXX_DiscardUnknown() {
- xxx_messageInfo_Failure.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Failure proto.InternalMessageInfo
-
-func (m *Failure) GetCode() Failure_FailureType {
- if m != nil && m.Code != nil {
- return *m.Code
- }
- return Failure_Failure_UnexpectedMessage
-}
-
-func (m *Failure) GetMessage() string {
- if m != nil && m.Message != nil {
- return *m.Message
- }
- return ""
-}
-
-// *
-// Response: Device is waiting for HW button press.
-// @auxstart
-// @next ButtonAck
-type ButtonRequest struct {
- Code *ButtonRequest_ButtonRequestType `protobuf:"varint,1,opt,name=code,enum=hw.trezor.messages.common.ButtonRequest_ButtonRequestType" json:"code,omitempty"`
- Data *string `protobuf:"bytes,2,opt,name=data" json:"data,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *ButtonRequest) Reset() { *m = ButtonRequest{} }
-func (m *ButtonRequest) String() string { return proto.CompactTextString(m) }
-func (*ButtonRequest) ProtoMessage() {}
-func (*ButtonRequest) Descriptor() ([]byte, []int) {
- return fileDescriptor_aaf30d059fdbc38d, []int{2}
-}
-
-func (m *ButtonRequest) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_ButtonRequest.Unmarshal(m, b)
-}
-func (m *ButtonRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_ButtonRequest.Marshal(b, m, deterministic)
-}
-func (m *ButtonRequest) XXX_Merge(src proto.Message) {
- xxx_messageInfo_ButtonRequest.Merge(m, src)
-}
-func (m *ButtonRequest) XXX_Size() int {
- return xxx_messageInfo_ButtonRequest.Size(m)
-}
-func (m *ButtonRequest) XXX_DiscardUnknown() {
- xxx_messageInfo_ButtonRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ButtonRequest proto.InternalMessageInfo
-
-func (m *ButtonRequest) GetCode() ButtonRequest_ButtonRequestType {
- if m != nil && m.Code != nil {
- return *m.Code
- }
- return ButtonRequest_ButtonRequest_Other
-}
-
-func (m *ButtonRequest) GetData() string {
- if m != nil && m.Data != nil {
- return *m.Data
- }
- return ""
-}
-
-// *
-// Request: Computer agrees to wait for HW button press
-// @auxend
-type ButtonAck struct {
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *ButtonAck) Reset() { *m = ButtonAck{} }
-func (m *ButtonAck) String() string { return proto.CompactTextString(m) }
-func (*ButtonAck) ProtoMessage() {}
-func (*ButtonAck) Descriptor() ([]byte, []int) {
- return fileDescriptor_aaf30d059fdbc38d, []int{3}
-}
-
-func (m *ButtonAck) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_ButtonAck.Unmarshal(m, b)
-}
-func (m *ButtonAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_ButtonAck.Marshal(b, m, deterministic)
-}
-func (m *ButtonAck) XXX_Merge(src proto.Message) {
- xxx_messageInfo_ButtonAck.Merge(m, src)
-}
-func (m *ButtonAck) XXX_Size() int {
- return xxx_messageInfo_ButtonAck.Size(m)
-}
-func (m *ButtonAck) XXX_DiscardUnknown() {
- xxx_messageInfo_ButtonAck.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ButtonAck proto.InternalMessageInfo
-
-// *
-// Response: Device is asking computer to show PIN matrix and awaits PIN encoded using this matrix scheme
-// @auxstart
-// @next PinMatrixAck
-type PinMatrixRequest struct {
- Type *PinMatrixRequest_PinMatrixRequestType `protobuf:"varint,1,opt,name=type,enum=hw.trezor.messages.common.PinMatrixRequest_PinMatrixRequestType" json:"type,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *PinMatrixRequest) Reset() { *m = PinMatrixRequest{} }
-func (m *PinMatrixRequest) String() string { return proto.CompactTextString(m) }
-func (*PinMatrixRequest) ProtoMessage() {}
-func (*PinMatrixRequest) Descriptor() ([]byte, []int) {
- return fileDescriptor_aaf30d059fdbc38d, []int{4}
-}
-
-func (m *PinMatrixRequest) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_PinMatrixRequest.Unmarshal(m, b)
-}
-func (m *PinMatrixRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_PinMatrixRequest.Marshal(b, m, deterministic)
-}
-func (m *PinMatrixRequest) XXX_Merge(src proto.Message) {
- xxx_messageInfo_PinMatrixRequest.Merge(m, src)
-}
-func (m *PinMatrixRequest) XXX_Size() int {
- return xxx_messageInfo_PinMatrixRequest.Size(m)
-}
-func (m *PinMatrixRequest) XXX_DiscardUnknown() {
- xxx_messageInfo_PinMatrixRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PinMatrixRequest proto.InternalMessageInfo
-
-func (m *PinMatrixRequest) GetType() PinMatrixRequest_PinMatrixRequestType {
- if m != nil && m.Type != nil {
- return *m.Type
- }
- return PinMatrixRequest_PinMatrixRequestType_Current
-}
-
-// *
-// Request: Computer responds with encoded PIN
-// @auxend
-type PinMatrixAck struct {
- Pin *string `protobuf:"bytes,1,req,name=pin" json:"pin,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *PinMatrixAck) Reset() { *m = PinMatrixAck{} }
-func (m *PinMatrixAck) String() string { return proto.CompactTextString(m) }
-func (*PinMatrixAck) ProtoMessage() {}
-func (*PinMatrixAck) Descriptor() ([]byte, []int) {
- return fileDescriptor_aaf30d059fdbc38d, []int{5}
-}
-
-func (m *PinMatrixAck) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_PinMatrixAck.Unmarshal(m, b)
-}
-func (m *PinMatrixAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_PinMatrixAck.Marshal(b, m, deterministic)
-}
-func (m *PinMatrixAck) XXX_Merge(src proto.Message) {
- xxx_messageInfo_PinMatrixAck.Merge(m, src)
-}
-func (m *PinMatrixAck) XXX_Size() int {
- return xxx_messageInfo_PinMatrixAck.Size(m)
-}
-func (m *PinMatrixAck) XXX_DiscardUnknown() {
- xxx_messageInfo_PinMatrixAck.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PinMatrixAck proto.InternalMessageInfo
-
-func (m *PinMatrixAck) GetPin() string {
- if m != nil && m.Pin != nil {
- return *m.Pin
- }
- return ""
-}
-
-// *
-// Response: Device awaits encryption passphrase
-// @auxstart
-// @next PassphraseAck
-type PassphraseRequest struct {
- OnDevice *bool `protobuf:"varint,1,opt,name=on_device,json=onDevice" json:"on_device,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *PassphraseRequest) Reset() { *m = PassphraseRequest{} }
-func (m *PassphraseRequest) String() string { return proto.CompactTextString(m) }
-func (*PassphraseRequest) ProtoMessage() {}
-func (*PassphraseRequest) Descriptor() ([]byte, []int) {
- return fileDescriptor_aaf30d059fdbc38d, []int{6}
-}
-
-func (m *PassphraseRequest) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_PassphraseRequest.Unmarshal(m, b)
-}
-func (m *PassphraseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_PassphraseRequest.Marshal(b, m, deterministic)
-}
-func (m *PassphraseRequest) XXX_Merge(src proto.Message) {
- xxx_messageInfo_PassphraseRequest.Merge(m, src)
-}
-func (m *PassphraseRequest) XXX_Size() int {
- return xxx_messageInfo_PassphraseRequest.Size(m)
-}
-func (m *PassphraseRequest) XXX_DiscardUnknown() {
- xxx_messageInfo_PassphraseRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PassphraseRequest proto.InternalMessageInfo
-
-func (m *PassphraseRequest) GetOnDevice() bool {
- if m != nil && m.OnDevice != nil {
- return *m.OnDevice
- }
- return false
-}
-
-// *
-// Request: Send passphrase back
-// @next PassphraseStateRequest
-type PassphraseAck struct {
- Passphrase *string `protobuf:"bytes,1,opt,name=passphrase" json:"passphrase,omitempty"`
- State []byte `protobuf:"bytes,2,opt,name=state" json:"state,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *PassphraseAck) Reset() { *m = PassphraseAck{} }
-func (m *PassphraseAck) String() string { return proto.CompactTextString(m) }
-func (*PassphraseAck) ProtoMessage() {}
-func (*PassphraseAck) Descriptor() ([]byte, []int) {
- return fileDescriptor_aaf30d059fdbc38d, []int{7}
-}
-
-func (m *PassphraseAck) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_PassphraseAck.Unmarshal(m, b)
-}
-func (m *PassphraseAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_PassphraseAck.Marshal(b, m, deterministic)
-}
-func (m *PassphraseAck) XXX_Merge(src proto.Message) {
- xxx_messageInfo_PassphraseAck.Merge(m, src)
-}
-func (m *PassphraseAck) XXX_Size() int {
- return xxx_messageInfo_PassphraseAck.Size(m)
-}
-func (m *PassphraseAck) XXX_DiscardUnknown() {
- xxx_messageInfo_PassphraseAck.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PassphraseAck proto.InternalMessageInfo
-
-func (m *PassphraseAck) GetPassphrase() string {
- if m != nil && m.Passphrase != nil {
- return *m.Passphrase
- }
- return ""
-}
-
-func (m *PassphraseAck) GetState() []byte {
- if m != nil {
- return m.State
- }
- return nil
-}
-
-// *
-// Response: Device awaits passphrase state
-// @next PassphraseStateAck
-type PassphraseStateRequest struct {
- State []byte `protobuf:"bytes,1,opt,name=state" json:"state,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *PassphraseStateRequest) Reset() { *m = PassphraseStateRequest{} }
-func (m *PassphraseStateRequest) String() string { return proto.CompactTextString(m) }
-func (*PassphraseStateRequest) ProtoMessage() {}
-func (*PassphraseStateRequest) Descriptor() ([]byte, []int) {
- return fileDescriptor_aaf30d059fdbc38d, []int{8}
-}
-
-func (m *PassphraseStateRequest) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_PassphraseStateRequest.Unmarshal(m, b)
-}
-func (m *PassphraseStateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_PassphraseStateRequest.Marshal(b, m, deterministic)
-}
-func (m *PassphraseStateRequest) XXX_Merge(src proto.Message) {
- xxx_messageInfo_PassphraseStateRequest.Merge(m, src)
-}
-func (m *PassphraseStateRequest) XXX_Size() int {
- return xxx_messageInfo_PassphraseStateRequest.Size(m)
-}
-func (m *PassphraseStateRequest) XXX_DiscardUnknown() {
- xxx_messageInfo_PassphraseStateRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PassphraseStateRequest proto.InternalMessageInfo
-
-func (m *PassphraseStateRequest) GetState() []byte {
- if m != nil {
- return m.State
- }
- return nil
-}
-
-// *
-// Request: Send passphrase state back
-// @auxend
-type PassphraseStateAck struct {
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *PassphraseStateAck) Reset() { *m = PassphraseStateAck{} }
-func (m *PassphraseStateAck) String() string { return proto.CompactTextString(m) }
-func (*PassphraseStateAck) ProtoMessage() {}
-func (*PassphraseStateAck) Descriptor() ([]byte, []int) {
- return fileDescriptor_aaf30d059fdbc38d, []int{9}
-}
-
-func (m *PassphraseStateAck) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_PassphraseStateAck.Unmarshal(m, b)
-}
-func (m *PassphraseStateAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_PassphraseStateAck.Marshal(b, m, deterministic)
-}
-func (m *PassphraseStateAck) XXX_Merge(src proto.Message) {
- xxx_messageInfo_PassphraseStateAck.Merge(m, src)
-}
-func (m *PassphraseStateAck) XXX_Size() int {
- return xxx_messageInfo_PassphraseStateAck.Size(m)
-}
-func (m *PassphraseStateAck) XXX_DiscardUnknown() {
- xxx_messageInfo_PassphraseStateAck.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PassphraseStateAck proto.InternalMessageInfo
-
-// *
-// Structure representing BIP32 (hierarchical deterministic) node
-// Used for imports of private key into the device and exporting public key out of device
-// @embed
-type HDNodeType struct {
- Depth *uint32 `protobuf:"varint,1,req,name=depth" json:"depth,omitempty"`
- Fingerprint *uint32 `protobuf:"varint,2,req,name=fingerprint" json:"fingerprint,omitempty"`
- ChildNum *uint32 `protobuf:"varint,3,req,name=child_num,json=childNum" json:"child_num,omitempty"`
- ChainCode []byte `protobuf:"bytes,4,req,name=chain_code,json=chainCode" json:"chain_code,omitempty"`
- PrivateKey []byte `protobuf:"bytes,5,opt,name=private_key,json=privateKey" json:"private_key,omitempty"`
- PublicKey []byte `protobuf:"bytes,6,opt,name=public_key,json=publicKey" json:"public_key,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *HDNodeType) Reset() { *m = HDNodeType{} }
-func (m *HDNodeType) String() string { return proto.CompactTextString(m) }
-func (*HDNodeType) ProtoMessage() {}
-func (*HDNodeType) Descriptor() ([]byte, []int) {
- return fileDescriptor_aaf30d059fdbc38d, []int{10}
-}
-
-func (m *HDNodeType) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_HDNodeType.Unmarshal(m, b)
-}
-func (m *HDNodeType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_HDNodeType.Marshal(b, m, deterministic)
-}
-func (m *HDNodeType) XXX_Merge(src proto.Message) {
- xxx_messageInfo_HDNodeType.Merge(m, src)
-}
-func (m *HDNodeType) XXX_Size() int {
- return xxx_messageInfo_HDNodeType.Size(m)
-}
-func (m *HDNodeType) XXX_DiscardUnknown() {
- xxx_messageInfo_HDNodeType.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_HDNodeType proto.InternalMessageInfo
-
-func (m *HDNodeType) GetDepth() uint32 {
- if m != nil && m.Depth != nil {
- return *m.Depth
- }
- return 0
-}
-
-func (m *HDNodeType) GetFingerprint() uint32 {
- if m != nil && m.Fingerprint != nil {
- return *m.Fingerprint
- }
- return 0
-}
-
-func (m *HDNodeType) GetChildNum() uint32 {
- if m != nil && m.ChildNum != nil {
- return *m.ChildNum
- }
- return 0
-}
-
-func (m *HDNodeType) GetChainCode() []byte {
- if m != nil {
- return m.ChainCode
- }
- return nil
-}
-
-func (m *HDNodeType) GetPrivateKey() []byte {
- if m != nil {
- return m.PrivateKey
- }
- return nil
-}
-
-func (m *HDNodeType) GetPublicKey() []byte {
- if m != nil {
- return m.PublicKey
- }
- return nil
-}
-
-func init() {
- proto.RegisterEnum("hw.trezor.messages.common.Failure_FailureType", Failure_FailureType_name, Failure_FailureType_value)
- proto.RegisterEnum("hw.trezor.messages.common.ButtonRequest_ButtonRequestType", ButtonRequest_ButtonRequestType_name, ButtonRequest_ButtonRequestType_value)
- proto.RegisterEnum("hw.trezor.messages.common.PinMatrixRequest_PinMatrixRequestType", PinMatrixRequest_PinMatrixRequestType_name, PinMatrixRequest_PinMatrixRequestType_value)
- proto.RegisterType((*Success)(nil), "hw.trezor.messages.common.Success")
- proto.RegisterType((*Failure)(nil), "hw.trezor.messages.common.Failure")
- proto.RegisterType((*ButtonRequest)(nil), "hw.trezor.messages.common.ButtonRequest")
- proto.RegisterType((*ButtonAck)(nil), "hw.trezor.messages.common.ButtonAck")
- proto.RegisterType((*PinMatrixRequest)(nil), "hw.trezor.messages.common.PinMatrixRequest")
- proto.RegisterType((*PinMatrixAck)(nil), "hw.trezor.messages.common.PinMatrixAck")
- proto.RegisterType((*PassphraseRequest)(nil), "hw.trezor.messages.common.PassphraseRequest")
- proto.RegisterType((*PassphraseAck)(nil), "hw.trezor.messages.common.PassphraseAck")
- proto.RegisterType((*PassphraseStateRequest)(nil), "hw.trezor.messages.common.PassphraseStateRequest")
- proto.RegisterType((*PassphraseStateAck)(nil), "hw.trezor.messages.common.PassphraseStateAck")
- proto.RegisterType((*HDNodeType)(nil), "hw.trezor.messages.common.HDNodeType")
-}
-
-func init() { proto.RegisterFile("messages-common.proto", fileDescriptor_aaf30d059fdbc38d) }
-
-var fileDescriptor_aaf30d059fdbc38d = []byte{
- // 846 bytes of a gzipped FileDescriptorProto
- 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x54, 0xcd, 0x52, 0x23, 0x37,
- 0x10, 0x2e, 0xff, 0x80, 0xed, 0xb6, 0xd9, 0x08, 0xc5, 0x80, 0x09, 0xb0, 0x38, 0xc3, 0x21, 0x5c,
- 0xe2, 0x4a, 0xe5, 0x98, 0x53, 0x58, 0x83, 0x2b, 0xd4, 0x16, 0x86, 0x1a, 0xd8, 0xda, 0xa3, 0x4b,
- 0xd1, 0xf4, 0x32, 0x2a, 0xcf, 0x48, 0x13, 0x8d, 0x06, 0xf0, 0x5e, 0xf2, 0x6a, 0x79, 0x89, 0xbc,
- 0x42, 0xaa, 0x52, 0xb9, 0xe4, 0x11, 0xb6, 0x34, 0x3f, 0x78, 0xc6, 0x66, 0x39, 0xcd, 0xe8, 0xfb,
- 0xbe, 0xee, 0x96, 0xba, 0x3f, 0x09, 0x76, 0x42, 0x8c, 0x63, 0x76, 0x8f, 0xf1, 0x8f, 0x5c, 0x85,
- 0xa1, 0x92, 0xa3, 0x48, 0x2b, 0xa3, 0xe8, 0xbe, 0xff, 0x38, 0x32, 0x1a, 0x3f, 0x2b, 0x3d, 0x2a,
- 0x04, 0xa3, 0x4c, 0xe0, 0x9c, 0x40, 0xeb, 0x36, 0xe1, 0x1c, 0xe3, 0x98, 0x0e, 0xa0, 0x95, 0xb3,
- 0x83, 0xda, 0xb0, 0x76, 0xda, 0x71, 0x8b, 0xa5, 0xf3, 0x77, 0x03, 0x5a, 0x13, 0x26, 0x82, 0x44,
- 0x23, 0x7d, 0x07, 0x4d, 0xae, 0xbc, 0x4c, 0xf2, 0xe6, 0xe7, 0xd1, 0xe8, 0xab, 0xa9, 0x47, 0x79,
- 0x44, 0xf1, 0xbd, 0x5b, 0x44, 0xe8, 0xa6, 0xb1, 0xe5, 0x4a, 0xf5, 0x6a, 0xa5, 0xff, 0xea, 0xd0,
- 0x2d, 0xe9, 0xe9, 0x11, 0xec, 0xe7, 0xcb, 0xd9, 0x07, 0x89, 0x4f, 0x11, 0x72, 0x83, 0xde, 0x55,
- 0x26, 0x26, 0x35, 0xfa, 0x1d, 0xec, 0x16, 0xf4, 0xbb, 0xc4, 0x18, 0x25, 0x2f, 0x72, 0x09, 0xa9,
- 0xd3, 0x1d, 0xd8, 0x2e, 0xb8, 0x73, 0x66, 0xd8, 0x85, 0xd6, 0x4a, 0x93, 0x06, 0x3d, 0x80, 0xbd,
- 0x02, 0x3e, 0xe3, 0x46, 0x28, 0x39, 0x66, 0x92, 0x63, 0x10, 0xa0, 0x47, 0x9a, 0x74, 0x0f, 0xbe,
- 0x2d, 0xc8, 0x1b, 0xb1, 0x4c, 0xb6, 0x41, 0x07, 0xd0, 0x2f, 0x11, 0xcb, 0x90, 0x4d, 0xba, 0x0b,
- 0xb4, 0xc4, 0x5c, 0xca, 0x07, 0x16, 0x08, 0x8f, 0xb4, 0xe8, 0x21, 0x0c, 0x0a, 0x3c, 0x07, 0x6f,
- 0xc5, 0xbd, 0x64, 0x26, 0xd1, 0x48, 0xda, 0x95, 0x7c, 0x5a, 0xd9, 0xf6, 0x67, 0xfb, 0xeb, 0x94,
- 0x8f, 0x34, 0x55, 0xe6, 0x42, 0xaa, 0xe4, 0xde, 0x9f, 0x24, 0xd2, 0x8b, 0x09, 0xac, 0x70, 0x97,
- 0x52, 0x18, 0xc1, 0x02, 0xf1, 0x19, 0x3d, 0xd2, 0x5d, 0xd9, 0xfa, 0x95, 0x88, 0x43, 0x66, 0xb8,
- 0x4f, 0x7a, 0x74, 0x1f, 0x76, 0x0a, 0x62, 0x22, 0x74, 0xf8, 0xc8, 0x34, 0x66, 0xb5, 0xb8, 0xf3,
- 0x4f, 0x13, 0xb6, 0xb2, 0xbe, 0xb9, 0xf8, 0x47, 0x82, 0xb1, 0xa1, 0xd3, 0xca, 0x74, 0x7f, 0x79,
- 0x65, 0xba, 0x95, 0xb8, 0xea, 0xaa, 0x34, 0x69, 0x0a, 0x4d, 0x8f, 0x19, 0x96, 0x8f, 0x39, 0xfd,
- 0x77, 0xfe, 0x6f, 0xc0, 0xf6, 0x9a, 0xde, 0xee, 0xbf, 0x02, 0xce, 0xae, 0x8d, 0x8f, 0x9a, 0xd4,
- 0xa8, 0x03, 0x6f, 0xab, 0xc4, 0x04, 0xf1, 0xfa, 0x01, 0xf5, 0x9d, 0xaf, 0x31, 0xf6, 0x55, 0x60,
- 0x67, 0x7d, 0x0c, 0x07, 0x55, 0xcd, 0x58, 0xc9, 0x4f, 0x42, 0x87, 0xd7, 0x89, 0x89, 0x12, 0x43,
- 0x1a, 0xd6, 0x47, 0x55, 0x81, 0x8b, 0x31, 0x9a, 0x73, 0x7c, 0x10, 0x1c, 0x49, 0x73, 0x9d, 0xce,
- 0xe3, 0x3f, 0x2a, 0x6d, 0xa7, 0x7f, 0x08, 0x83, 0x2a, 0xfd, 0x51, 0x44, 0x98, 0x07, 0x6f, 0xae,
- 0x07, 0xdf, 0x68, 0x65, 0x90, 0x9b, 0x31, 0x0b, 0x02, 0xd2, 0xb2, 0xa3, 0xae, 0xd2, 0xd6, 0x07,
- 0x77, 0x4f, 0xa4, 0xbd, 0xbe, 0xeb, 0x62, 0x3e, 0x63, 0x1f, 0xf9, 0x9c, 0x74, 0xec, 0xe8, 0xaa,
- 0x82, 0x33, 0xcf, 0xd3, 0x18, 0x5b, 0x2b, 0x1c, 0xc0, 0xde, 0x4a, 0xd1, 0xe4, 0xf7, 0x40, 0xf0,
- 0xf7, 0xb8, 0x20, 0x5d, 0x7a, 0x02, 0xc7, 0x55, 0xf2, 0x4a, 0x62, 0xa8, 0xa4, 0xe0, 0xf6, 0x3c,
- 0x63, 0x95, 0x48, 0x43, 0x7a, 0xeb, 0xd5, 0x0b, 0xd1, 0xa5, 0xb4, 0x3d, 0xdb, 0xa2, 0x43, 0x38,
- 0x5c, 0x29, 0xc1, 0xe2, 0x38, 0xf2, 0x35, 0x8b, 0xd3, 0xbb, 0x49, 0xde, 0xd0, 0x1f, 0xe0, 0xa4,
- 0xaa, 0xf8, 0x20, 0xe7, 0x52, 0x3d, 0xca, 0x73, 0xd4, 0xe2, 0x81, 0xd9, 0xcb, 0x75, 0xc3, 0x8c,
- 0x4f, 0xbe, 0x71, 0xba, 0xd0, 0xc9, 0x84, 0x67, 0x7c, 0xee, 0xfc, 0x5b, 0x03, 0x62, 0x2d, 0xca,
- 0x8c, 0x16, 0x4f, 0x85, 0xf1, 0xee, 0xa0, 0x69, 0x16, 0x51, 0x61, 0xbc, 0x5f, 0x5f, 0x31, 0xde,
- 0x6a, 0xe8, 0x1a, 0x90, 0xd9, 0xcf, 0x66, 0x73, 0xfe, 0x84, 0xfe, 0x4b, 0xac, 0x3d, 0xda, 0x4b,
- 0xf8, 0x6c, 0x9c, 0x68, 0x8d, 0xd2, 0x90, 0x1a, 0xfd, 0x1e, 0x8e, 0x5e, 0x54, 0x4c, 0xf1, 0x71,
- 0x22, 0x74, 0x6c, 0x48, 0xdd, 0x1a, 0xf3, 0x6b, 0x92, 0x5b, 0xe4, 0x4a, 0x7a, 0xa4, 0xe1, 0x0c,
- 0xa1, 0xf7, 0xac, 0x39, 0xe3, 0x73, 0x4a, 0xa0, 0x11, 0x09, 0x39, 0xa8, 0x0d, 0xeb, 0xa7, 0x1d,
- 0xd7, 0xfe, 0x3a, 0x3f, 0xc1, 0xf6, 0xb2, 0xaf, 0x45, 0x37, 0x0e, 0xa0, 0xa3, 0xe4, 0xcc, 0x4b,
- 0x1d, 0x96, 0xb6, 0xa4, 0xed, 0xb6, 0x95, 0xcc, 0x1c, 0xe7, 0x5c, 0xc0, 0xd6, 0x32, 0xc2, 0x26,
- 0x7d, 0x0b, 0x10, 0x3d, 0x03, 0xf9, 0xdb, 0x5d, 0x42, 0x68, 0x1f, 0x36, 0x62, 0xc3, 0x4c, 0xf6,
- 0xd8, 0xf6, 0xdc, 0x6c, 0xe1, 0x8c, 0x60, 0x77, 0x99, 0xe6, 0xd6, 0x42, 0x45, 0xf5, 0x67, 0x7d,
- 0xad, 0xac, 0xef, 0x03, 0x5d, 0xd1, 0xdb, 0x61, 0xfe, 0x55, 0x03, 0xf8, 0xed, 0x7c, 0xaa, 0xbc,
- 0xec, 0xbd, 0xee, 0xc3, 0x86, 0x87, 0x91, 0xf1, 0xd3, 0x13, 0x6e, 0xb9, 0xd9, 0x82, 0x0e, 0xa1,
- 0xfb, 0x49, 0xc8, 0x7b, 0xd4, 0x91, 0x16, 0xd2, 0x0c, 0xea, 0x29, 0x57, 0x86, 0xec, 0x81, 0xb9,
- 0x2f, 0x02, 0x6f, 0x26, 0x93, 0x70, 0xd0, 0x48, 0xf9, 0x76, 0x0a, 0x4c, 0x93, 0x90, 0x1e, 0x01,
- 0x70, 0x9f, 0x09, 0x39, 0x4b, 0x9f, 0xa6, 0xe6, 0xb0, 0x7e, 0xda, 0x73, 0x3b, 0x29, 0x32, 0xb6,
- 0x6f, 0xcc, 0x31, 0x74, 0xa3, 0xd4, 0x6f, 0x38, 0x9b, 0xe3, 0x62, 0xb0, 0x91, 0x6e, 0x1a, 0x72,
- 0xe8, 0x3d, 0x2e, 0x6c, 0x7c, 0x94, 0xde, 0x8e, 0x94, 0xdf, 0x4c, 0xf9, 0x4e, 0x54, 0xdc, 0x97,
- 0x2f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xb2, 0x7d, 0x20, 0xa6, 0x35, 0x07, 0x00, 0x00,
-}
diff --git a/accounts/usbwallet/trezor/messages-common.proto b/accounts/usbwallet/trezor/messages-common.proto
deleted file mode 100644
index 75a983b0a3..0000000000
--- a/accounts/usbwallet/trezor/messages-common.proto
+++ /dev/null
@@ -1,147 +0,0 @@
-// This file originates from the SatoshiLabs Trezor `common` repository at:
-// https://github.com/trezor/trezor-common/blob/master/protob/messages-common.proto
-// dated 28.05.2019, commit 893fd219d4a01bcffa0cd9cfa631856371ec5aa9.
-
-syntax = "proto2";
-package hw.trezor.messages.common;
-
-/**
- * Response: Success of the previous request
- * @end
- */
-message Success {
- optional string message = 1; // human readable description of action or request-specific payload
-}
-
-/**
- * Response: Failure of the previous request
- * @end
- */
-message Failure {
- optional FailureType code = 1; // computer-readable definition of the error state
- optional string message = 2; // human-readable message of the error state
- enum FailureType {
- Failure_UnexpectedMessage = 1;
- Failure_ButtonExpected = 2;
- Failure_DataError = 3;
- Failure_ActionCancelled = 4;
- Failure_PinExpected = 5;
- Failure_PinCancelled = 6;
- Failure_PinInvalid = 7;
- Failure_InvalidSignature = 8;
- Failure_ProcessError = 9;
- Failure_NotEnoughFunds = 10;
- Failure_NotInitialized = 11;
- Failure_PinMismatch = 12;
- Failure_FirmwareError = 99;
- }
-}
-
-/**
- * Response: Device is waiting for HW button press.
- * @auxstart
- * @next ButtonAck
- */
-message ButtonRequest {
- optional ButtonRequestType code = 1;
- optional string data = 2;
- /**
- * Type of button request
- */
- enum ButtonRequestType {
- ButtonRequest_Other = 1;
- ButtonRequest_FeeOverThreshold = 2;
- ButtonRequest_ConfirmOutput = 3;
- ButtonRequest_ResetDevice = 4;
- ButtonRequest_ConfirmWord = 5;
- ButtonRequest_WipeDevice = 6;
- ButtonRequest_ProtectCall = 7;
- ButtonRequest_SignTx = 8;
- ButtonRequest_FirmwareCheck = 9;
- ButtonRequest_Address = 10;
- ButtonRequest_PublicKey = 11;
- ButtonRequest_MnemonicWordCount = 12;
- ButtonRequest_MnemonicInput = 13;
- ButtonRequest_PassphraseType = 14;
- ButtonRequest_UnknownDerivationPath = 15;
- }
-}
-
-/**
- * Request: Computer agrees to wait for HW button press
- * @auxend
- */
-message ButtonAck {
-}
-
-/**
- * Response: Device is asking computer to show PIN matrix and awaits PIN encoded using this matrix scheme
- * @auxstart
- * @next PinMatrixAck
- */
-message PinMatrixRequest {
- optional PinMatrixRequestType type = 1;
- /**
- * Type of PIN request
- */
- enum PinMatrixRequestType {
- PinMatrixRequestType_Current = 1;
- PinMatrixRequestType_NewFirst = 2;
- PinMatrixRequestType_NewSecond = 3;
- }
-}
-
-/**
- * Request: Computer responds with encoded PIN
- * @auxend
- */
-message PinMatrixAck {
- required string pin = 1; // matrix encoded PIN entered by user
-}
-
-/**
- * Response: Device awaits encryption passphrase
- * @auxstart
- * @next PassphraseAck
- */
-message PassphraseRequest {
- optional bool on_device = 1; // passphrase is being entered on the device
-}
-
-/**
- * Request: Send passphrase back
- * @next PassphraseStateRequest
- */
-message PassphraseAck {
- optional string passphrase = 1;
- optional bytes state = 2; // expected device state
-}
-
-/**
- * Response: Device awaits passphrase state
- * @next PassphraseStateAck
- */
-message PassphraseStateRequest {
- optional bytes state = 1; // actual device state
-}
-
-/**
- * Request: Send passphrase state back
- * @auxend
- */
-message PassphraseStateAck {
-}
-
-/**
- * Structure representing BIP32 (hierarchical deterministic) node
- * Used for imports of private key into the device and exporting public key out of device
- * @embed
- */
-message HDNodeType {
- required uint32 depth = 1;
- required uint32 fingerprint = 2;
- required uint32 child_num = 3;
- required bytes chain_code = 4;
- optional bytes private_key = 5;
- optional bytes public_key = 6;
-}
diff --git a/accounts/usbwallet/trezor/messages-ethereum.pb.go b/accounts/usbwallet/trezor/messages-ethereum.pb.go
deleted file mode 100644
index 230a48279d..0000000000
--- a/accounts/usbwallet/trezor/messages-ethereum.pb.go
+++ /dev/null
@@ -1,698 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: messages-ethereum.proto
-
-package trezor
-
-import (
- fmt "fmt"
- math "math"
-
- proto "github.com/golang/protobuf/proto"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
-
-// *
-// Request: Ask device for public key corresponding to address_n path
-// @start
-// @next EthereumPublicKey
-// @next Failure
-type EthereumGetPublicKey struct {
- AddressN []uint32 `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
- ShowDisplay *bool `protobuf:"varint,2,opt,name=show_display,json=showDisplay" json:"show_display,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *EthereumGetPublicKey) Reset() { *m = EthereumGetPublicKey{} }
-func (m *EthereumGetPublicKey) String() string { return proto.CompactTextString(m) }
-func (*EthereumGetPublicKey) ProtoMessage() {}
-func (*EthereumGetPublicKey) Descriptor() ([]byte, []int) {
- return fileDescriptor_cb33f46ba915f15c, []int{0}
-}
-
-func (m *EthereumGetPublicKey) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_EthereumGetPublicKey.Unmarshal(m, b)
-}
-func (m *EthereumGetPublicKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_EthereumGetPublicKey.Marshal(b, m, deterministic)
-}
-func (m *EthereumGetPublicKey) XXX_Merge(src proto.Message) {
- xxx_messageInfo_EthereumGetPublicKey.Merge(m, src)
-}
-func (m *EthereumGetPublicKey) XXX_Size() int {
- return xxx_messageInfo_EthereumGetPublicKey.Size(m)
-}
-func (m *EthereumGetPublicKey) XXX_DiscardUnknown() {
- xxx_messageInfo_EthereumGetPublicKey.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EthereumGetPublicKey proto.InternalMessageInfo
-
-func (m *EthereumGetPublicKey) GetAddressN() []uint32 {
- if m != nil {
- return m.AddressN
- }
- return nil
-}
-
-func (m *EthereumGetPublicKey) GetShowDisplay() bool {
- if m != nil && m.ShowDisplay != nil {
- return *m.ShowDisplay
- }
- return false
-}
-
-// *
-// Response: Contains public key derived from device private seed
-// @end
-type EthereumPublicKey struct {
- Node *HDNodeType `protobuf:"bytes,1,opt,name=node" json:"node,omitempty"`
- Xpub *string `protobuf:"bytes,2,opt,name=xpub" json:"xpub,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *EthereumPublicKey) Reset() { *m = EthereumPublicKey{} }
-func (m *EthereumPublicKey) String() string { return proto.CompactTextString(m) }
-func (*EthereumPublicKey) ProtoMessage() {}
-func (*EthereumPublicKey) Descriptor() ([]byte, []int) {
- return fileDescriptor_cb33f46ba915f15c, []int{1}
-}
-
-func (m *EthereumPublicKey) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_EthereumPublicKey.Unmarshal(m, b)
-}
-func (m *EthereumPublicKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_EthereumPublicKey.Marshal(b, m, deterministic)
-}
-func (m *EthereumPublicKey) XXX_Merge(src proto.Message) {
- xxx_messageInfo_EthereumPublicKey.Merge(m, src)
-}
-func (m *EthereumPublicKey) XXX_Size() int {
- return xxx_messageInfo_EthereumPublicKey.Size(m)
-}
-func (m *EthereumPublicKey) XXX_DiscardUnknown() {
- xxx_messageInfo_EthereumPublicKey.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EthereumPublicKey proto.InternalMessageInfo
-
-func (m *EthereumPublicKey) GetNode() *HDNodeType {
- if m != nil {
- return m.Node
- }
- return nil
-}
-
-func (m *EthereumPublicKey) GetXpub() string {
- if m != nil && m.Xpub != nil {
- return *m.Xpub
- }
- return ""
-}
-
-// *
-// Request: Ask device for Ethereum address corresponding to address_n path
-// @start
-// @next EthereumAddress
-// @next Failure
-type EthereumGetAddress struct {
- AddressN []uint32 `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
- ShowDisplay *bool `protobuf:"varint,2,opt,name=show_display,json=showDisplay" json:"show_display,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *EthereumGetAddress) Reset() { *m = EthereumGetAddress{} }
-func (m *EthereumGetAddress) String() string { return proto.CompactTextString(m) }
-func (*EthereumGetAddress) ProtoMessage() {}
-func (*EthereumGetAddress) Descriptor() ([]byte, []int) {
- return fileDescriptor_cb33f46ba915f15c, []int{2}
-}
-
-func (m *EthereumGetAddress) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_EthereumGetAddress.Unmarshal(m, b)
-}
-func (m *EthereumGetAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_EthereumGetAddress.Marshal(b, m, deterministic)
-}
-func (m *EthereumGetAddress) XXX_Merge(src proto.Message) {
- xxx_messageInfo_EthereumGetAddress.Merge(m, src)
-}
-func (m *EthereumGetAddress) XXX_Size() int {
- return xxx_messageInfo_EthereumGetAddress.Size(m)
-}
-func (m *EthereumGetAddress) XXX_DiscardUnknown() {
- xxx_messageInfo_EthereumGetAddress.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EthereumGetAddress proto.InternalMessageInfo
-
-func (m *EthereumGetAddress) GetAddressN() []uint32 {
- if m != nil {
- return m.AddressN
- }
- return nil
-}
-
-func (m *EthereumGetAddress) GetShowDisplay() bool {
- if m != nil && m.ShowDisplay != nil {
- return *m.ShowDisplay
- }
- return false
-}
-
-// *
-// Response: Contains an Ethereum address derived from device private seed
-// @end
-type EthereumAddress struct {
- AddressBin []byte `protobuf:"bytes,1,opt,name=addressBin" json:"addressBin,omitempty"`
- AddressHex *string `protobuf:"bytes,2,opt,name=addressHex" json:"addressHex,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *EthereumAddress) Reset() { *m = EthereumAddress{} }
-func (m *EthereumAddress) String() string { return proto.CompactTextString(m) }
-func (*EthereumAddress) ProtoMessage() {}
-func (*EthereumAddress) Descriptor() ([]byte, []int) {
- return fileDescriptor_cb33f46ba915f15c, []int{3}
-}
-
-func (m *EthereumAddress) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_EthereumAddress.Unmarshal(m, b)
-}
-func (m *EthereumAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_EthereumAddress.Marshal(b, m, deterministic)
-}
-func (m *EthereumAddress) XXX_Merge(src proto.Message) {
- xxx_messageInfo_EthereumAddress.Merge(m, src)
-}
-func (m *EthereumAddress) XXX_Size() int {
- return xxx_messageInfo_EthereumAddress.Size(m)
-}
-func (m *EthereumAddress) XXX_DiscardUnknown() {
- xxx_messageInfo_EthereumAddress.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EthereumAddress proto.InternalMessageInfo
-
-func (m *EthereumAddress) GetAddressBin() []byte {
- if m != nil {
- return m.AddressBin
- }
- return nil
-}
-
-func (m *EthereumAddress) GetAddressHex() string {
- if m != nil && m.AddressHex != nil {
- return *m.AddressHex
- }
- return ""
-}
-
-// *
-// Request: Ask device to sign transaction
-// All fields are optional from the protocol's point of view. Each field defaults to value `0` if missing.
-// Note: the first at most 1024 bytes of data MUST be transmitted as part of this message.
-// @start
-// @next EthereumTxRequest
-// @next Failure
-type EthereumSignTx struct {
- AddressN []uint32 `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
- Nonce []byte `protobuf:"bytes,2,opt,name=nonce" json:"nonce,omitempty"`
- GasPrice []byte `protobuf:"bytes,3,opt,name=gas_price,json=gasPrice" json:"gas_price,omitempty"`
- GasLimit []byte `protobuf:"bytes,4,opt,name=gas_limit,json=gasLimit" json:"gas_limit,omitempty"`
- ToBin []byte `protobuf:"bytes,5,opt,name=toBin" json:"toBin,omitempty"`
- ToHex *string `protobuf:"bytes,11,opt,name=toHex" json:"toHex,omitempty"`
- Value []byte `protobuf:"bytes,6,opt,name=value" json:"value,omitempty"`
- DataInitialChunk []byte `protobuf:"bytes,7,opt,name=data_initial_chunk,json=dataInitialChunk" json:"data_initial_chunk,omitempty"`
- DataLength *uint32 `protobuf:"varint,8,opt,name=data_length,json=dataLength" json:"data_length,omitempty"`
- ChainId *uint32 `protobuf:"varint,9,opt,name=chain_id,json=chainId" json:"chain_id,omitempty"`
- TxType *uint32 `protobuf:"varint,10,opt,name=tx_type,json=txType" json:"tx_type,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *EthereumSignTx) Reset() { *m = EthereumSignTx{} }
-func (m *EthereumSignTx) String() string { return proto.CompactTextString(m) }
-func (*EthereumSignTx) ProtoMessage() {}
-func (*EthereumSignTx) Descriptor() ([]byte, []int) {
- return fileDescriptor_cb33f46ba915f15c, []int{4}
-}
-
-func (m *EthereumSignTx) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_EthereumSignTx.Unmarshal(m, b)
-}
-func (m *EthereumSignTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_EthereumSignTx.Marshal(b, m, deterministic)
-}
-func (m *EthereumSignTx) XXX_Merge(src proto.Message) {
- xxx_messageInfo_EthereumSignTx.Merge(m, src)
-}
-func (m *EthereumSignTx) XXX_Size() int {
- return xxx_messageInfo_EthereumSignTx.Size(m)
-}
-func (m *EthereumSignTx) XXX_DiscardUnknown() {
- xxx_messageInfo_EthereumSignTx.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EthereumSignTx proto.InternalMessageInfo
-
-func (m *EthereumSignTx) GetAddressN() []uint32 {
- if m != nil {
- return m.AddressN
- }
- return nil
-}
-
-func (m *EthereumSignTx) GetNonce() []byte {
- if m != nil {
- return m.Nonce
- }
- return nil
-}
-
-func (m *EthereumSignTx) GetGasPrice() []byte {
- if m != nil {
- return m.GasPrice
- }
- return nil
-}
-
-func (m *EthereumSignTx) GetGasLimit() []byte {
- if m != nil {
- return m.GasLimit
- }
- return nil
-}
-
-func (m *EthereumSignTx) GetToBin() []byte {
- if m != nil {
- return m.ToBin
- }
- return nil
-}
-
-func (m *EthereumSignTx) GetToHex() string {
- if m != nil && m.ToHex != nil {
- return *m.ToHex
- }
- return ""
-}
-
-func (m *EthereumSignTx) GetValue() []byte {
- if m != nil {
- return m.Value
- }
- return nil
-}
-
-func (m *EthereumSignTx) GetDataInitialChunk() []byte {
- if m != nil {
- return m.DataInitialChunk
- }
- return nil
-}
-
-func (m *EthereumSignTx) GetDataLength() uint32 {
- if m != nil && m.DataLength != nil {
- return *m.DataLength
- }
- return 0
-}
-
-func (m *EthereumSignTx) GetChainId() uint32 {
- if m != nil && m.ChainId != nil {
- return *m.ChainId
- }
- return 0
-}
-
-func (m *EthereumSignTx) GetTxType() uint32 {
- if m != nil && m.TxType != nil {
- return *m.TxType
- }
- return 0
-}
-
-// *
-// Response: Device asks for more data from transaction payload, or returns the signature.
-// If data_length is set, device awaits that many more bytes of payload.
-// Otherwise, the signature_* fields contain the computed transaction signature. All three fields will be present.
-// @end
-// @next EthereumTxAck
-type EthereumTxRequest struct {
- DataLength *uint32 `protobuf:"varint,1,opt,name=data_length,json=dataLength" json:"data_length,omitempty"`
- SignatureV *uint32 `protobuf:"varint,2,opt,name=signature_v,json=signatureV" json:"signature_v,omitempty"`
- SignatureR []byte `protobuf:"bytes,3,opt,name=signature_r,json=signatureR" json:"signature_r,omitempty"`
- SignatureS []byte `protobuf:"bytes,4,opt,name=signature_s,json=signatureS" json:"signature_s,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *EthereumTxRequest) Reset() { *m = EthereumTxRequest{} }
-func (m *EthereumTxRequest) String() string { return proto.CompactTextString(m) }
-func (*EthereumTxRequest) ProtoMessage() {}
-func (*EthereumTxRequest) Descriptor() ([]byte, []int) {
- return fileDescriptor_cb33f46ba915f15c, []int{5}
-}
-
-func (m *EthereumTxRequest) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_EthereumTxRequest.Unmarshal(m, b)
-}
-func (m *EthereumTxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_EthereumTxRequest.Marshal(b, m, deterministic)
-}
-func (m *EthereumTxRequest) XXX_Merge(src proto.Message) {
- xxx_messageInfo_EthereumTxRequest.Merge(m, src)
-}
-func (m *EthereumTxRequest) XXX_Size() int {
- return xxx_messageInfo_EthereumTxRequest.Size(m)
-}
-func (m *EthereumTxRequest) XXX_DiscardUnknown() {
- xxx_messageInfo_EthereumTxRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EthereumTxRequest proto.InternalMessageInfo
-
-func (m *EthereumTxRequest) GetDataLength() uint32 {
- if m != nil && m.DataLength != nil {
- return *m.DataLength
- }
- return 0
-}
-
-func (m *EthereumTxRequest) GetSignatureV() uint32 {
- if m != nil && m.SignatureV != nil {
- return *m.SignatureV
- }
- return 0
-}
-
-func (m *EthereumTxRequest) GetSignatureR() []byte {
- if m != nil {
- return m.SignatureR
- }
- return nil
-}
-
-func (m *EthereumTxRequest) GetSignatureS() []byte {
- if m != nil {
- return m.SignatureS
- }
- return nil
-}
-
-// *
-// Request: Transaction payload data.
-// @next EthereumTxRequest
-type EthereumTxAck struct {
- DataChunk []byte `protobuf:"bytes,1,opt,name=data_chunk,json=dataChunk" json:"data_chunk,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *EthereumTxAck) Reset() { *m = EthereumTxAck{} }
-func (m *EthereumTxAck) String() string { return proto.CompactTextString(m) }
-func (*EthereumTxAck) ProtoMessage() {}
-func (*EthereumTxAck) Descriptor() ([]byte, []int) {
- return fileDescriptor_cb33f46ba915f15c, []int{6}
-}
-
-func (m *EthereumTxAck) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_EthereumTxAck.Unmarshal(m, b)
-}
-func (m *EthereumTxAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_EthereumTxAck.Marshal(b, m, deterministic)
-}
-func (m *EthereumTxAck) XXX_Merge(src proto.Message) {
- xxx_messageInfo_EthereumTxAck.Merge(m, src)
-}
-func (m *EthereumTxAck) XXX_Size() int {
- return xxx_messageInfo_EthereumTxAck.Size(m)
-}
-func (m *EthereumTxAck) XXX_DiscardUnknown() {
- xxx_messageInfo_EthereumTxAck.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EthereumTxAck proto.InternalMessageInfo
-
-func (m *EthereumTxAck) GetDataChunk() []byte {
- if m != nil {
- return m.DataChunk
- }
- return nil
-}
-
-// *
-// Request: Ask device to sign message
-// @start
-// @next EthereumMessageSignature
-// @next Failure
-type EthereumSignMessage struct {
- AddressN []uint32 `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
- Message []byte `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *EthereumSignMessage) Reset() { *m = EthereumSignMessage{} }
-func (m *EthereumSignMessage) String() string { return proto.CompactTextString(m) }
-func (*EthereumSignMessage) ProtoMessage() {}
-func (*EthereumSignMessage) Descriptor() ([]byte, []int) {
- return fileDescriptor_cb33f46ba915f15c, []int{7}
-}
-
-func (m *EthereumSignMessage) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_EthereumSignMessage.Unmarshal(m, b)
-}
-func (m *EthereumSignMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_EthereumSignMessage.Marshal(b, m, deterministic)
-}
-func (m *EthereumSignMessage) XXX_Merge(src proto.Message) {
- xxx_messageInfo_EthereumSignMessage.Merge(m, src)
-}
-func (m *EthereumSignMessage) XXX_Size() int {
- return xxx_messageInfo_EthereumSignMessage.Size(m)
-}
-func (m *EthereumSignMessage) XXX_DiscardUnknown() {
- xxx_messageInfo_EthereumSignMessage.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EthereumSignMessage proto.InternalMessageInfo
-
-func (m *EthereumSignMessage) GetAddressN() []uint32 {
- if m != nil {
- return m.AddressN
- }
- return nil
-}
-
-func (m *EthereumSignMessage) GetMessage() []byte {
- if m != nil {
- return m.Message
- }
- return nil
-}
-
-// *
-// Response: Signed message
-// @end
-type EthereumMessageSignature struct {
- AddressBin []byte `protobuf:"bytes,1,opt,name=addressBin" json:"addressBin,omitempty"`
- Signature []byte `protobuf:"bytes,2,opt,name=signature" json:"signature,omitempty"`
- AddressHex *string `protobuf:"bytes,3,opt,name=addressHex" json:"addressHex,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *EthereumMessageSignature) Reset() { *m = EthereumMessageSignature{} }
-func (m *EthereumMessageSignature) String() string { return proto.CompactTextString(m) }
-func (*EthereumMessageSignature) ProtoMessage() {}
-func (*EthereumMessageSignature) Descriptor() ([]byte, []int) {
- return fileDescriptor_cb33f46ba915f15c, []int{8}
-}
-
-func (m *EthereumMessageSignature) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_EthereumMessageSignature.Unmarshal(m, b)
-}
-func (m *EthereumMessageSignature) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_EthereumMessageSignature.Marshal(b, m, deterministic)
-}
-func (m *EthereumMessageSignature) XXX_Merge(src proto.Message) {
- xxx_messageInfo_EthereumMessageSignature.Merge(m, src)
-}
-func (m *EthereumMessageSignature) XXX_Size() int {
- return xxx_messageInfo_EthereumMessageSignature.Size(m)
-}
-func (m *EthereumMessageSignature) XXX_DiscardUnknown() {
- xxx_messageInfo_EthereumMessageSignature.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EthereumMessageSignature proto.InternalMessageInfo
-
-func (m *EthereumMessageSignature) GetAddressBin() []byte {
- if m != nil {
- return m.AddressBin
- }
- return nil
-}
-
-func (m *EthereumMessageSignature) GetSignature() []byte {
- if m != nil {
- return m.Signature
- }
- return nil
-}
-
-func (m *EthereumMessageSignature) GetAddressHex() string {
- if m != nil && m.AddressHex != nil {
- return *m.AddressHex
- }
- return ""
-}
-
-// *
-// Request: Ask device to verify message
-// @start
-// @next Success
-// @next Failure
-type EthereumVerifyMessage struct {
- AddressBin []byte `protobuf:"bytes,1,opt,name=addressBin" json:"addressBin,omitempty"`
- Signature []byte `protobuf:"bytes,2,opt,name=signature" json:"signature,omitempty"`
- Message []byte `protobuf:"bytes,3,opt,name=message" json:"message,omitempty"`
- AddressHex *string `protobuf:"bytes,4,opt,name=addressHex" json:"addressHex,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *EthereumVerifyMessage) Reset() { *m = EthereumVerifyMessage{} }
-func (m *EthereumVerifyMessage) String() string { return proto.CompactTextString(m) }
-func (*EthereumVerifyMessage) ProtoMessage() {}
-func (*EthereumVerifyMessage) Descriptor() ([]byte, []int) {
- return fileDescriptor_cb33f46ba915f15c, []int{9}
-}
-
-func (m *EthereumVerifyMessage) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_EthereumVerifyMessage.Unmarshal(m, b)
-}
-func (m *EthereumVerifyMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_EthereumVerifyMessage.Marshal(b, m, deterministic)
-}
-func (m *EthereumVerifyMessage) XXX_Merge(src proto.Message) {
- xxx_messageInfo_EthereumVerifyMessage.Merge(m, src)
-}
-func (m *EthereumVerifyMessage) XXX_Size() int {
- return xxx_messageInfo_EthereumVerifyMessage.Size(m)
-}
-func (m *EthereumVerifyMessage) XXX_DiscardUnknown() {
- xxx_messageInfo_EthereumVerifyMessage.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EthereumVerifyMessage proto.InternalMessageInfo
-
-func (m *EthereumVerifyMessage) GetAddressBin() []byte {
- if m != nil {
- return m.AddressBin
- }
- return nil
-}
-
-func (m *EthereumVerifyMessage) GetSignature() []byte {
- if m != nil {
- return m.Signature
- }
- return nil
-}
-
-func (m *EthereumVerifyMessage) GetMessage() []byte {
- if m != nil {
- return m.Message
- }
- return nil
-}
-
-func (m *EthereumVerifyMessage) GetAddressHex() string {
- if m != nil && m.AddressHex != nil {
- return *m.AddressHex
- }
- return ""
-}
-
-func init() {
- proto.RegisterType((*EthereumGetPublicKey)(nil), "hw.trezor.messages.ethereum.EthereumGetPublicKey")
- proto.RegisterType((*EthereumPublicKey)(nil), "hw.trezor.messages.ethereum.EthereumPublicKey")
- proto.RegisterType((*EthereumGetAddress)(nil), "hw.trezor.messages.ethereum.EthereumGetAddress")
- proto.RegisterType((*EthereumAddress)(nil), "hw.trezor.messages.ethereum.EthereumAddress")
- proto.RegisterType((*EthereumSignTx)(nil), "hw.trezor.messages.ethereum.EthereumSignTx")
- proto.RegisterType((*EthereumTxRequest)(nil), "hw.trezor.messages.ethereum.EthereumTxRequest")
- proto.RegisterType((*EthereumTxAck)(nil), "hw.trezor.messages.ethereum.EthereumTxAck")
- proto.RegisterType((*EthereumSignMessage)(nil), "hw.trezor.messages.ethereum.EthereumSignMessage")
- proto.RegisterType((*EthereumMessageSignature)(nil), "hw.trezor.messages.ethereum.EthereumMessageSignature")
- proto.RegisterType((*EthereumVerifyMessage)(nil), "hw.trezor.messages.ethereum.EthereumVerifyMessage")
-}
-
-func init() { proto.RegisterFile("messages-ethereum.proto", fileDescriptor_cb33f46ba915f15c) }
-
-var fileDescriptor_cb33f46ba915f15c = []byte{
- // 593 bytes of a gzipped FileDescriptorProto
- 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0x4d, 0x6f, 0xd3, 0x40,
- 0x10, 0x95, 0x9b, 0xb4, 0x49, 0x26, 0x0d, 0x1f, 0xa6, 0x55, 0x17, 0x0a, 0x34, 0x18, 0x21, 0xe5,
- 0x00, 0x3e, 0x70, 0x43, 0xe2, 0xd2, 0x52, 0x44, 0x2b, 0x4a, 0x55, 0xdc, 0xa8, 0x57, 0x6b, 0x63,
- 0x6f, 0xe3, 0x55, 0x9d, 0xdd, 0xe0, 0x5d, 0xb7, 0x0e, 0x7f, 0x82, 0x23, 0xff, 0x87, 0x5f, 0x86,
- 0xf6, 0x2b, 0x71, 0x52, 0x54, 0x0e, 0xbd, 0x65, 0xde, 0xbc, 0x7d, 0xf3, 0x66, 0xf4, 0x62, 0xd8,
- 0x99, 0x10, 0x21, 0xf0, 0x98, 0x88, 0x77, 0x44, 0x66, 0xa4, 0x20, 0xe5, 0x24, 0x9c, 0x16, 0x5c,
- 0x72, 0x7f, 0x37, 0xbb, 0x09, 0x65, 0x41, 0x7e, 0xf2, 0x22, 0x74, 0x94, 0xd0, 0x51, 0x9e, 0x6d,
- 0xcf, 0x5f, 0x25, 0x7c, 0x32, 0xe1, 0xcc, 0xbc, 0x09, 0x2e, 0x60, 0xeb, 0xb3, 0xa5, 0x7c, 0x21,
- 0xf2, 0xac, 0x1c, 0xe5, 0x34, 0xf9, 0x4a, 0x66, 0xfe, 0x2e, 0x74, 0x70, 0x9a, 0x16, 0x44, 0x88,
- 0x98, 0x21, 0xaf, 0xdf, 0x18, 0xf4, 0xa2, 0xb6, 0x05, 0x4e, 0xfd, 0x57, 0xb0, 0x29, 0x32, 0x7e,
- 0x13, 0xa7, 0x54, 0x4c, 0x73, 0x3c, 0x43, 0x6b, 0x7d, 0x6f, 0xd0, 0x8e, 0xba, 0x0a, 0x3b, 0x34,
- 0x50, 0x30, 0x82, 0xc7, 0x4e, 0x77, 0x21, 0xfa, 0x01, 0x9a, 0x8c, 0xa7, 0x04, 0x79, 0x7d, 0x6f,
- 0xd0, 0x7d, 0xff, 0x26, 0xfc, 0x87, 0x5f, 0x6b, 0xee, 0xe8, 0xf0, 0x94, 0xa7, 0x64, 0x38, 0x9b,
- 0x92, 0x48, 0x3f, 0xf1, 0x7d, 0x68, 0x56, 0xd3, 0x72, 0xa4, 0x47, 0x75, 0x22, 0xfd, 0x3b, 0x18,
- 0x82, 0x5f, 0xf3, 0xbe, 0x6f, 0xdc, 0xdd, 0xdb, 0xf9, 0x77, 0x78, 0xe8, 0x54, 0x9d, 0xe4, 0x4b,
- 0x00, 0xab, 0x70, 0x40, 0x99, 0x76, 0xbf, 0x19, 0xd5, 0x90, 0x5a, 0xff, 0x88, 0x54, 0xd6, 0x62,
- 0x0d, 0x09, 0xfe, 0xac, 0xc1, 0x03, 0xa7, 0x79, 0x4e, 0xc7, 0x6c, 0x58, 0xdd, 0xed, 0x72, 0x0b,
- 0xd6, 0x19, 0x67, 0x09, 0xd1, 0x52, 0x9b, 0x91, 0x29, 0xd4, 0x93, 0x31, 0x16, 0xf1, 0xb4, 0xa0,
- 0x09, 0x41, 0x0d, 0xdd, 0x69, 0x8f, 0xb1, 0x38, 0x53, 0xb5, 0x6b, 0xe6, 0x74, 0x42, 0x25, 0x6a,
- 0xce, 0x9b, 0x27, 0xaa, 0x56, 0x7a, 0x92, 0x2b, 0xeb, 0xeb, 0x46, 0x4f, 0x17, 0x06, 0x55, 0x86,
- 0xbb, 0xda, 0xb0, 0x29, 0x14, 0x7a, 0x8d, 0xf3, 0x92, 0xa0, 0x0d, 0xc3, 0xd5, 0x85, 0xff, 0x16,
- 0xfc, 0x14, 0x4b, 0x1c, 0x53, 0x46, 0x25, 0xc5, 0x79, 0x9c, 0x64, 0x25, 0xbb, 0x42, 0x2d, 0x4d,
- 0x79, 0xa4, 0x3a, 0xc7, 0xa6, 0xf1, 0x49, 0xe1, 0xfe, 0x1e, 0x74, 0x35, 0x3b, 0x27, 0x6c, 0x2c,
- 0x33, 0xd4, 0xee, 0x7b, 0x83, 0x5e, 0x04, 0x0a, 0x3a, 0xd1, 0x88, 0xff, 0x14, 0xda, 0x49, 0x86,
- 0x29, 0x8b, 0x69, 0x8a, 0x3a, 0xba, 0xdb, 0xd2, 0xf5, 0x71, 0xea, 0xef, 0x40, 0x4b, 0x56, 0xb1,
- 0x9c, 0x4d, 0x09, 0x02, 0xdd, 0xd9, 0x90, 0x95, 0xca, 0x41, 0xf0, 0xdb, 0x5b, 0x44, 0x6a, 0x58,
- 0x45, 0xe4, 0x47, 0x49, 0x84, 0x5c, 0x1d, 0xe5, 0xdd, 0x1a, 0xb5, 0x07, 0x5d, 0x41, 0xc7, 0x0c,
- 0xcb, 0xb2, 0x20, 0xf1, 0xb5, 0xbe, 0x68, 0x2f, 0x82, 0x39, 0x74, 0xb1, 0x4c, 0x28, 0xec, 0x61,
- 0x17, 0x84, 0x68, 0x99, 0x20, 0xec, 0x71, 0x17, 0x84, 0xf3, 0x20, 0x84, 0xde, 0xc2, 0xd8, 0x7e,
- 0x72, 0xe5, 0xbf, 0x00, 0xed, 0xc0, 0x5e, 0xc9, 0xe4, 0xa5, 0xa3, 0x10, 0x7d, 0x9e, 0xe0, 0x04,
- 0x9e, 0xd4, 0xd3, 0xf0, 0xcd, 0x64, 0xff, 0xee, 0x48, 0x20, 0x68, 0xd9, 0xff, 0x88, 0x0d, 0x85,
- 0x2b, 0x83, 0x0a, 0x90, 0x53, 0xb3, 0x4a, 0xe7, 0xce, 0xda, 0x7f, 0x83, 0xfb, 0x1c, 0x3a, 0xf3,
- 0x3d, 0xac, 0xee, 0x02, 0x58, 0x89, 0x75, 0xe3, 0x56, 0xac, 0x7f, 0x79, 0xb0, 0xed, 0x46, 0x5f,
- 0x90, 0x82, 0x5e, 0xce, 0xdc, 0x2a, 0xf7, 0x9b, 0x5b, 0xdb, 0xb5, 0xb1, 0xb4, 0xeb, 0x8a, 0xa3,
- 0xe6, 0xaa, 0xa3, 0x83, 0x8f, 0xf0, 0x3a, 0xe1, 0x93, 0x50, 0x60, 0xc9, 0x45, 0x46, 0x73, 0x3c,
- 0x12, 0xee, 0x03, 0x93, 0xd3, 0x91, 0xf9, 0xe2, 0x8d, 0xca, 0xcb, 0x83, 0xed, 0xa1, 0x06, 0xad,
- 0x5b, 0xb7, 0xc2, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x8a, 0xce, 0x81, 0xc8, 0x59, 0x05, 0x00,
- 0x00,
-}
diff --git a/accounts/usbwallet/trezor/messages-ethereum.proto b/accounts/usbwallet/trezor/messages-ethereum.proto
deleted file mode 100644
index 096bed2e4a..0000000000
--- a/accounts/usbwallet/trezor/messages-ethereum.proto
+++ /dev/null
@@ -1,131 +0,0 @@
-// This file originates from the SatoshiLabs Trezor `common` repository at:
-// https://github.com/trezor/trezor-common/blob/master/protob/messages-ethereum.proto
-// dated 28.05.2019, commit 893fd219d4a01bcffa0cd9cfa631856371ec5aa9.
-
-syntax = "proto2";
-package hw.trezor.messages.ethereum;
-
-// Sugar for easier handling in Java
-option java_package = "com.satoshilabs.trezor.lib.protobuf";
-option java_outer_classname = "TrezorMessageEthereum";
-
-import "messages-common.proto";
-
-
-/**
- * Request: Ask device for public key corresponding to address_n path
- * @start
- * @next EthereumPublicKey
- * @next Failure
- */
-message EthereumGetPublicKey {
- repeated uint32 address_n = 1; // BIP-32 path to derive the key from master node
- optional bool show_display = 2; // optionally show on display before sending the result
-}
-
-/**
- * Response: Contains public key derived from device private seed
- * @end
- */
-message EthereumPublicKey {
- optional hw.trezor.messages.common.HDNodeType node = 1; // BIP32 public node
- optional string xpub = 2; // serialized form of public node
-}
-
-/**
- * Request: Ask device for Ethereum address corresponding to address_n path
- * @start
- * @next EthereumAddress
- * @next Failure
- */
-message EthereumGetAddress {
- repeated uint32 address_n = 1; // BIP-32 path to derive the key from master node
- optional bool show_display = 2; // optionally show on display before sending the result
-}
-
-/**
- * Response: Contains an Ethereum address derived from device private seed
- * @end
- */
-message EthereumAddress {
- optional bytes addressBin = 1; // Ethereum address as 20 bytes (legacy firmwares)
- optional string addressHex = 2; // Ethereum address as hex string (newer firmwares)
-}
-
-/**
- * Request: Ask device to sign transaction
- * All fields are optional from the protocol's point of view. Each field defaults to value `0` if missing.
- * Note: the first at most 1024 bytes of data MUST be transmitted as part of this message.
- * @start
- * @next EthereumTxRequest
- * @next Failure
- */
-message EthereumSignTx {
- repeated uint32 address_n = 1; // BIP-32 path to derive the key from master node
- optional bytes nonce = 2; // <=256 bit unsigned big endian
- optional bytes gas_price = 3; // <=256 bit unsigned big endian (in wei)
- optional bytes gas_limit = 4; // <=256 bit unsigned big endian
- optional bytes toBin = 5; // recipient address (20 bytes, legacy firmware)
- optional string toHex = 11; // recipient address (hex string, newer firmware)
- optional bytes value = 6; // <=256 bit unsigned big endian (in wei)
- optional bytes data_initial_chunk = 7; // The initial data chunk (<= 1024 bytes)
- optional uint32 data_length = 8; // Length of transaction payload
- optional uint32 chain_id = 9; // Chain Id for EIP 155
- optional uint32 tx_type = 10; // (only for Wanchain)
-}
-
-/**
- * Response: Device asks for more data from transaction payload, or returns the signature.
- * If data_length is set, device awaits that many more bytes of payload.
- * Otherwise, the signature_* fields contain the computed transaction signature. All three fields will be present.
- * @end
- * @next EthereumTxAck
- */
-message EthereumTxRequest {
- optional uint32 data_length = 1; // Number of bytes being requested (<= 1024)
- optional uint32 signature_v = 2; // Computed signature (recovery parameter, limited to 27 or 28)
- optional bytes signature_r = 3; // Computed signature R component (256 bit)
- optional bytes signature_s = 4; // Computed signature S component (256 bit)
-}
-
-/**
- * Request: Transaction payload data.
- * @next EthereumTxRequest
- */
-message EthereumTxAck {
- optional bytes data_chunk = 1; // Bytes from transaction payload (<= 1024 bytes)
-}
-
-/**
- * Request: Ask device to sign message
- * @start
- * @next EthereumMessageSignature
- * @next Failure
- */
-message EthereumSignMessage {
- repeated uint32 address_n = 1; // BIP-32 path to derive the key from master node
- optional bytes message = 2; // message to be signed
-}
-
-/**
- * Response: Signed message
- * @end
- */
-message EthereumMessageSignature {
- optional bytes addressBin = 1; // address used to sign the message (20 bytes, legacy firmware)
- optional bytes signature = 2; // signature of the message
- optional string addressHex = 3; // address used to sign the message (hex string, newer firmware)
-}
-
-/**
- * Request: Ask device to verify message
- * @start
- * @next Success
- * @next Failure
- */
-message EthereumVerifyMessage {
- optional bytes addressBin = 1; // address to verify (20 bytes, legacy firmware)
- optional bytes signature = 2; // signature to verify
- optional bytes message = 3; // message to verify
- optional string addressHex = 4; // address to verify (hex string, newer firmware)
-}
diff --git a/accounts/usbwallet/trezor/messages-management.pb.go b/accounts/usbwallet/trezor/messages-management.pb.go
deleted file mode 100644
index 91bfca1e3f..0000000000
--- a/accounts/usbwallet/trezor/messages-management.pb.go
+++ /dev/null
@@ -1,1621 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: messages-management.proto
-
-package trezor
-
-import (
- fmt "fmt"
- math "math"
-
- proto "github.com/golang/protobuf/proto"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
-
-// *
-// Structure representing passphrase source
-type ApplySettings_PassphraseSourceType int32
-
-const (
- ApplySettings_ASK ApplySettings_PassphraseSourceType = 0
- ApplySettings_DEVICE ApplySettings_PassphraseSourceType = 1
- ApplySettings_HOST ApplySettings_PassphraseSourceType = 2
-)
-
-var ApplySettings_PassphraseSourceType_name = map[int32]string{
- 0: "ASK",
- 1: "DEVICE",
- 2: "HOST",
-}
-
-var ApplySettings_PassphraseSourceType_value = map[string]int32{
- "ASK": 0,
- "DEVICE": 1,
- "HOST": 2,
-}
-
-func (x ApplySettings_PassphraseSourceType) Enum() *ApplySettings_PassphraseSourceType {
- p := new(ApplySettings_PassphraseSourceType)
- *p = x
- return p
-}
-
-func (x ApplySettings_PassphraseSourceType) String() string {
- return proto.EnumName(ApplySettings_PassphraseSourceType_name, int32(x))
-}
-
-func (x *ApplySettings_PassphraseSourceType) UnmarshalJSON(data []byte) error {
- value, err := proto.UnmarshalJSONEnum(ApplySettings_PassphraseSourceType_value, data, "ApplySettings_PassphraseSourceType")
- if err != nil {
- return err
- }
- *x = ApplySettings_PassphraseSourceType(value)
- return nil
-}
-
-func (ApplySettings_PassphraseSourceType) EnumDescriptor() ([]byte, []int) {
- return fileDescriptor_0c720c20d27aa029, []int{4, 0}
-}
-
-// *
-// Type of recovery procedure. These should be used as bitmask, e.g.,
-// `RecoveryDeviceType_ScrambledWords | RecoveryDeviceType_Matrix`
-// listing every method supported by the host computer.
-//
-// Note that ScrambledWords must be supported by every implementation
-// for backward compatibility; there is no way to not support it.
-type RecoveryDevice_RecoveryDeviceType int32
-
-const (
- // use powers of two when extending this field
- RecoveryDevice_RecoveryDeviceType_ScrambledWords RecoveryDevice_RecoveryDeviceType = 0
- RecoveryDevice_RecoveryDeviceType_Matrix RecoveryDevice_RecoveryDeviceType = 1
-)
-
-var RecoveryDevice_RecoveryDeviceType_name = map[int32]string{
- 0: "RecoveryDeviceType_ScrambledWords",
- 1: "RecoveryDeviceType_Matrix",
-}
-
-var RecoveryDevice_RecoveryDeviceType_value = map[string]int32{
- "RecoveryDeviceType_ScrambledWords": 0,
- "RecoveryDeviceType_Matrix": 1,
-}
-
-func (x RecoveryDevice_RecoveryDeviceType) Enum() *RecoveryDevice_RecoveryDeviceType {
- p := new(RecoveryDevice_RecoveryDeviceType)
- *p = x
- return p
-}
-
-func (x RecoveryDevice_RecoveryDeviceType) String() string {
- return proto.EnumName(RecoveryDevice_RecoveryDeviceType_name, int32(x))
-}
-
-func (x *RecoveryDevice_RecoveryDeviceType) UnmarshalJSON(data []byte) error {
- value, err := proto.UnmarshalJSONEnum(RecoveryDevice_RecoveryDeviceType_value, data, "RecoveryDevice_RecoveryDeviceType")
- if err != nil {
- return err
- }
- *x = RecoveryDevice_RecoveryDeviceType(value)
- return nil
-}
-
-func (RecoveryDevice_RecoveryDeviceType) EnumDescriptor() ([]byte, []int) {
- return fileDescriptor_0c720c20d27aa029, []int{17, 0}
-}
-
-// *
-// Type of Recovery Word request
-type WordRequest_WordRequestType int32
-
-const (
- WordRequest_WordRequestType_Plain WordRequest_WordRequestType = 0
- WordRequest_WordRequestType_Matrix9 WordRequest_WordRequestType = 1
- WordRequest_WordRequestType_Matrix6 WordRequest_WordRequestType = 2
-)
-
-var WordRequest_WordRequestType_name = map[int32]string{
- 0: "WordRequestType_Plain",
- 1: "WordRequestType_Matrix9",
- 2: "WordRequestType_Matrix6",
-}
-
-var WordRequest_WordRequestType_value = map[string]int32{
- "WordRequestType_Plain": 0,
- "WordRequestType_Matrix9": 1,
- "WordRequestType_Matrix6": 2,
-}
-
-func (x WordRequest_WordRequestType) Enum() *WordRequest_WordRequestType {
- p := new(WordRequest_WordRequestType)
- *p = x
- return p
-}
-
-func (x WordRequest_WordRequestType) String() string {
- return proto.EnumName(WordRequest_WordRequestType_name, int32(x))
-}
-
-func (x *WordRequest_WordRequestType) UnmarshalJSON(data []byte) error {
- value, err := proto.UnmarshalJSONEnum(WordRequest_WordRequestType_value, data, "WordRequest_WordRequestType")
- if err != nil {
- return err
- }
- *x = WordRequest_WordRequestType(value)
- return nil
-}
-
-func (WordRequest_WordRequestType) EnumDescriptor() ([]byte, []int) {
- return fileDescriptor_0c720c20d27aa029, []int{18, 0}
-}
-
-// *
-// Request: Reset device to default state and ask for device details
-// @start
-// @next Features
-type Initialize struct {
- State []byte `protobuf:"bytes,1,opt,name=state" json:"state,omitempty"`
- SkipPassphrase *bool `protobuf:"varint,2,opt,name=skip_passphrase,json=skipPassphrase" json:"skip_passphrase,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Initialize) Reset() { *m = Initialize{} }
-func (m *Initialize) String() string { return proto.CompactTextString(m) }
-func (*Initialize) ProtoMessage() {}
-func (*Initialize) Descriptor() ([]byte, []int) {
- return fileDescriptor_0c720c20d27aa029, []int{0}
-}
-
-func (m *Initialize) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Initialize.Unmarshal(m, b)
-}
-func (m *Initialize) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Initialize.Marshal(b, m, deterministic)
-}
-func (m *Initialize) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Initialize.Merge(m, src)
-}
-func (m *Initialize) XXX_Size() int {
- return xxx_messageInfo_Initialize.Size(m)
-}
-func (m *Initialize) XXX_DiscardUnknown() {
- xxx_messageInfo_Initialize.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Initialize proto.InternalMessageInfo
-
-func (m *Initialize) GetState() []byte {
- if m != nil {
- return m.State
- }
- return nil
-}
-
-func (m *Initialize) GetSkipPassphrase() bool {
- if m != nil && m.SkipPassphrase != nil {
- return *m.SkipPassphrase
- }
- return false
-}
-
-// *
-// Request: Ask for device details (no device reset)
-// @start
-// @next Features
-type GetFeatures struct {
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *GetFeatures) Reset() { *m = GetFeatures{} }
-func (m *GetFeatures) String() string { return proto.CompactTextString(m) }
-func (*GetFeatures) ProtoMessage() {}
-func (*GetFeatures) Descriptor() ([]byte, []int) {
- return fileDescriptor_0c720c20d27aa029, []int{1}
-}
-
-func (m *GetFeatures) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_GetFeatures.Unmarshal(m, b)
-}
-func (m *GetFeatures) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_GetFeatures.Marshal(b, m, deterministic)
-}
-func (m *GetFeatures) XXX_Merge(src proto.Message) {
- xxx_messageInfo_GetFeatures.Merge(m, src)
-}
-func (m *GetFeatures) XXX_Size() int {
- return xxx_messageInfo_GetFeatures.Size(m)
-}
-func (m *GetFeatures) XXX_DiscardUnknown() {
- xxx_messageInfo_GetFeatures.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_GetFeatures proto.InternalMessageInfo
-
-// *
-// Response: Reports various information about the device
-// @end
-type Features struct {
- Vendor *string `protobuf:"bytes,1,opt,name=vendor" json:"vendor,omitempty"`
- MajorVersion *uint32 `protobuf:"varint,2,opt,name=major_version,json=majorVersion" json:"major_version,omitempty"`
- MinorVersion *uint32 `protobuf:"varint,3,opt,name=minor_version,json=minorVersion" json:"minor_version,omitempty"`
- PatchVersion *uint32 `protobuf:"varint,4,opt,name=patch_version,json=patchVersion" json:"patch_version,omitempty"`
- BootloaderMode *bool `protobuf:"varint,5,opt,name=bootloader_mode,json=bootloaderMode" json:"bootloader_mode,omitempty"`
- DeviceId *string `protobuf:"bytes,6,opt,name=device_id,json=deviceId" json:"device_id,omitempty"`
- PinProtection *bool `protobuf:"varint,7,opt,name=pin_protection,json=pinProtection" json:"pin_protection,omitempty"`
- PassphraseProtection *bool `protobuf:"varint,8,opt,name=passphrase_protection,json=passphraseProtection" json:"passphrase_protection,omitempty"`
- Language *string `protobuf:"bytes,9,opt,name=language" json:"language,omitempty"`
- Label *string `protobuf:"bytes,10,opt,name=label" json:"label,omitempty"`
- Initialized *bool `protobuf:"varint,12,opt,name=initialized" json:"initialized,omitempty"`
- Revision []byte `protobuf:"bytes,13,opt,name=revision" json:"revision,omitempty"`
- BootloaderHash []byte `protobuf:"bytes,14,opt,name=bootloader_hash,json=bootloaderHash" json:"bootloader_hash,omitempty"`
- Imported *bool `protobuf:"varint,15,opt,name=imported" json:"imported,omitempty"`
- PinCached *bool `protobuf:"varint,16,opt,name=pin_cached,json=pinCached" json:"pin_cached,omitempty"`
- PassphraseCached *bool `protobuf:"varint,17,opt,name=passphrase_cached,json=passphraseCached" json:"passphrase_cached,omitempty"`
- FirmwarePresent *bool `protobuf:"varint,18,opt,name=firmware_present,json=firmwarePresent" json:"firmware_present,omitempty"`
- NeedsBackup *bool `protobuf:"varint,19,opt,name=needs_backup,json=needsBackup" json:"needs_backup,omitempty"`
- Flags *uint32 `protobuf:"varint,20,opt,name=flags" json:"flags,omitempty"`
- Model *string `protobuf:"bytes,21,opt,name=model" json:"model,omitempty"`
- FwMajor *uint32 `protobuf:"varint,22,opt,name=fw_major,json=fwMajor" json:"fw_major,omitempty"`
- FwMinor *uint32 `protobuf:"varint,23,opt,name=fw_minor,json=fwMinor" json:"fw_minor,omitempty"`
- FwPatch *uint32 `protobuf:"varint,24,opt,name=fw_patch,json=fwPatch" json:"fw_patch,omitempty"`
- FwVendor *string `protobuf:"bytes,25,opt,name=fw_vendor,json=fwVendor" json:"fw_vendor,omitempty"`
- FwVendorKeys []byte `protobuf:"bytes,26,opt,name=fw_vendor_keys,json=fwVendorKeys" json:"fw_vendor_keys,omitempty"`
- UnfinishedBackup *bool `protobuf:"varint,27,opt,name=unfinished_backup,json=unfinishedBackup" json:"unfinished_backup,omitempty"`
- NoBackup *bool `protobuf:"varint,28,opt,name=no_backup,json=noBackup" json:"no_backup,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Features) Reset() { *m = Features{} }
-func (m *Features) String() string { return proto.CompactTextString(m) }
-func (*Features) ProtoMessage() {}
-func (*Features) Descriptor() ([]byte, []int) {
- return fileDescriptor_0c720c20d27aa029, []int{2}
-}
-
-func (m *Features) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Features.Unmarshal(m, b)
-}
-func (m *Features) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Features.Marshal(b, m, deterministic)
-}
-func (m *Features) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Features.Merge(m, src)
-}
-func (m *Features) XXX_Size() int {
- return xxx_messageInfo_Features.Size(m)
-}
-func (m *Features) XXX_DiscardUnknown() {
- xxx_messageInfo_Features.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Features proto.InternalMessageInfo
-
-func (m *Features) GetVendor() string {
- if m != nil && m.Vendor != nil {
- return *m.Vendor
- }
- return ""
-}
-
-func (m *Features) GetMajorVersion() uint32 {
- if m != nil && m.MajorVersion != nil {
- return *m.MajorVersion
- }
- return 0
-}
-
-func (m *Features) GetMinorVersion() uint32 {
- if m != nil && m.MinorVersion != nil {
- return *m.MinorVersion
- }
- return 0
-}
-
-func (m *Features) GetPatchVersion() uint32 {
- if m != nil && m.PatchVersion != nil {
- return *m.PatchVersion
- }
- return 0
-}
-
-func (m *Features) GetBootloaderMode() bool {
- if m != nil && m.BootloaderMode != nil {
- return *m.BootloaderMode
- }
- return false
-}
-
-func (m *Features) GetDeviceId() string {
- if m != nil && m.DeviceId != nil {
- return *m.DeviceId
- }
- return ""
-}
-
-func (m *Features) GetPinProtection() bool {
- if m != nil && m.PinProtection != nil {
- return *m.PinProtection
- }
- return false
-}
-
-func (m *Features) GetPassphraseProtection() bool {
- if m != nil && m.PassphraseProtection != nil {
- return *m.PassphraseProtection
- }
- return false
-}
-
-func (m *Features) GetLanguage() string {
- if m != nil && m.Language != nil {
- return *m.Language
- }
- return ""
-}
-
-func (m *Features) GetLabel() string {
- if m != nil && m.Label != nil {
- return *m.Label
- }
- return ""
-}
-
-func (m *Features) GetInitialized() bool {
- if m != nil && m.Initialized != nil {
- return *m.Initialized
- }
- return false
-}
-
-func (m *Features) GetRevision() []byte {
- if m != nil {
- return m.Revision
- }
- return nil
-}
-
-func (m *Features) GetBootloaderHash() []byte {
- if m != nil {
- return m.BootloaderHash
- }
- return nil
-}
-
-func (m *Features) GetImported() bool {
- if m != nil && m.Imported != nil {
- return *m.Imported
- }
- return false
-}
-
-func (m *Features) GetPinCached() bool {
- if m != nil && m.PinCached != nil {
- return *m.PinCached
- }
- return false
-}
-
-func (m *Features) GetPassphraseCached() bool {
- if m != nil && m.PassphraseCached != nil {
- return *m.PassphraseCached
- }
- return false
-}
-
-func (m *Features) GetFirmwarePresent() bool {
- if m != nil && m.FirmwarePresent != nil {
- return *m.FirmwarePresent
- }
- return false
-}
-
-func (m *Features) GetNeedsBackup() bool {
- if m != nil && m.NeedsBackup != nil {
- return *m.NeedsBackup
- }
- return false
-}
-
-func (m *Features) GetFlags() uint32 {
- if m != nil && m.Flags != nil {
- return *m.Flags
- }
- return 0
-}
-
-func (m *Features) GetModel() string {
- if m != nil && m.Model != nil {
- return *m.Model
- }
- return ""
-}
-
-func (m *Features) GetFwMajor() uint32 {
- if m != nil && m.FwMajor != nil {
- return *m.FwMajor
- }
- return 0
-}
-
-func (m *Features) GetFwMinor() uint32 {
- if m != nil && m.FwMinor != nil {
- return *m.FwMinor
- }
- return 0
-}
-
-func (m *Features) GetFwPatch() uint32 {
- if m != nil && m.FwPatch != nil {
- return *m.FwPatch
- }
- return 0
-}
-
-func (m *Features) GetFwVendor() string {
- if m != nil && m.FwVendor != nil {
- return *m.FwVendor
- }
- return ""
-}
-
-func (m *Features) GetFwVendorKeys() []byte {
- if m != nil {
- return m.FwVendorKeys
- }
- return nil
-}
-
-func (m *Features) GetUnfinishedBackup() bool {
- if m != nil && m.UnfinishedBackup != nil {
- return *m.UnfinishedBackup
- }
- return false
-}
-
-func (m *Features) GetNoBackup() bool {
- if m != nil && m.NoBackup != nil {
- return *m.NoBackup
- }
- return false
-}
-
-// *
-// Request: clear session (removes cached PIN, passphrase, etc).
-// @start
-// @next Success
-type ClearSession struct {
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *ClearSession) Reset() { *m = ClearSession{} }
-func (m *ClearSession) String() string { return proto.CompactTextString(m) }
-func (*ClearSession) ProtoMessage() {}
-func (*ClearSession) Descriptor() ([]byte, []int) {
- return fileDescriptor_0c720c20d27aa029, []int{3}
-}
-
-func (m *ClearSession) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_ClearSession.Unmarshal(m, b)
-}
-func (m *ClearSession) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_ClearSession.Marshal(b, m, deterministic)
-}
-func (m *ClearSession) XXX_Merge(src proto.Message) {
- xxx_messageInfo_ClearSession.Merge(m, src)
-}
-func (m *ClearSession) XXX_Size() int {
- return xxx_messageInfo_ClearSession.Size(m)
-}
-func (m *ClearSession) XXX_DiscardUnknown() {
- xxx_messageInfo_ClearSession.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ClearSession proto.InternalMessageInfo
-
-// *
-// Request: change language and/or label of the device
-// @start
-// @next Success
-// @next Failure
-type ApplySettings struct {
- Language *string `protobuf:"bytes,1,opt,name=language" json:"language,omitempty"`
- Label *string `protobuf:"bytes,2,opt,name=label" json:"label,omitempty"`
- UsePassphrase *bool `protobuf:"varint,3,opt,name=use_passphrase,json=usePassphrase" json:"use_passphrase,omitempty"`
- Homescreen []byte `protobuf:"bytes,4,opt,name=homescreen" json:"homescreen,omitempty"`
- PassphraseSource *ApplySettings_PassphraseSourceType `protobuf:"varint,5,opt,name=passphrase_source,json=passphraseSource,enum=hw.trezor.messages.management.ApplySettings_PassphraseSourceType" json:"passphrase_source,omitempty"`
- AutoLockDelayMs *uint32 `protobuf:"varint,6,opt,name=auto_lock_delay_ms,json=autoLockDelayMs" json:"auto_lock_delay_ms,omitempty"`
- DisplayRotation *uint32 `protobuf:"varint,7,opt,name=display_rotation,json=displayRotation" json:"display_rotation,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *ApplySettings) Reset() { *m = ApplySettings{} }
-func (m *ApplySettings) String() string { return proto.CompactTextString(m) }
-func (*ApplySettings) ProtoMessage() {}
-func (*ApplySettings) Descriptor() ([]byte, []int) {
- return fileDescriptor_0c720c20d27aa029, []int{4}
-}
-
-func (m *ApplySettings) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_ApplySettings.Unmarshal(m, b)
-}
-func (m *ApplySettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_ApplySettings.Marshal(b, m, deterministic)
-}
-func (m *ApplySettings) XXX_Merge(src proto.Message) {
- xxx_messageInfo_ApplySettings.Merge(m, src)
-}
-func (m *ApplySettings) XXX_Size() int {
- return xxx_messageInfo_ApplySettings.Size(m)
-}
-func (m *ApplySettings) XXX_DiscardUnknown() {
- xxx_messageInfo_ApplySettings.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ApplySettings proto.InternalMessageInfo
-
-func (m *ApplySettings) GetLanguage() string {
- if m != nil && m.Language != nil {
- return *m.Language
- }
- return ""
-}
-
-func (m *ApplySettings) GetLabel() string {
- if m != nil && m.Label != nil {
- return *m.Label
- }
- return ""
-}
-
-func (m *ApplySettings) GetUsePassphrase() bool {
- if m != nil && m.UsePassphrase != nil {
- return *m.UsePassphrase
- }
- return false
-}
-
-func (m *ApplySettings) GetHomescreen() []byte {
- if m != nil {
- return m.Homescreen
- }
- return nil
-}
-
-func (m *ApplySettings) GetPassphraseSource() ApplySettings_PassphraseSourceType {
- if m != nil && m.PassphraseSource != nil {
- return *m.PassphraseSource
- }
- return ApplySettings_ASK
-}
-
-func (m *ApplySettings) GetAutoLockDelayMs() uint32 {
- if m != nil && m.AutoLockDelayMs != nil {
- return *m.AutoLockDelayMs
- }
- return 0
-}
-
-func (m *ApplySettings) GetDisplayRotation() uint32 {
- if m != nil && m.DisplayRotation != nil {
- return *m.DisplayRotation
- }
- return 0
-}
-
-// *
-// Request: set flags of the device
-// @start
-// @next Success
-// @next Failure
-type ApplyFlags struct {
- Flags *uint32 `protobuf:"varint,1,opt,name=flags" json:"flags,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *ApplyFlags) Reset() { *m = ApplyFlags{} }
-func (m *ApplyFlags) String() string { return proto.CompactTextString(m) }
-func (*ApplyFlags) ProtoMessage() {}
-func (*ApplyFlags) Descriptor() ([]byte, []int) {
- return fileDescriptor_0c720c20d27aa029, []int{5}
-}
-
-func (m *ApplyFlags) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_ApplyFlags.Unmarshal(m, b)
-}
-func (m *ApplyFlags) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_ApplyFlags.Marshal(b, m, deterministic)
-}
-func (m *ApplyFlags) XXX_Merge(src proto.Message) {
- xxx_messageInfo_ApplyFlags.Merge(m, src)
-}
-func (m *ApplyFlags) XXX_Size() int {
- return xxx_messageInfo_ApplyFlags.Size(m)
-}
-func (m *ApplyFlags) XXX_DiscardUnknown() {
- xxx_messageInfo_ApplyFlags.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ApplyFlags proto.InternalMessageInfo
-
-func (m *ApplyFlags) GetFlags() uint32 {
- if m != nil && m.Flags != nil {
- return *m.Flags
- }
- return 0
-}
-
-// *
-// Request: Starts workflow for setting/changing/removing the PIN
-// @start
-// @next Success
-// @next Failure
-type ChangePin struct {
- Remove *bool `protobuf:"varint,1,opt,name=remove" json:"remove,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *ChangePin) Reset() { *m = ChangePin{} }
-func (m *ChangePin) String() string { return proto.CompactTextString(m) }
-func (*ChangePin) ProtoMessage() {}
-func (*ChangePin) Descriptor() ([]byte, []int) {
- return fileDescriptor_0c720c20d27aa029, []int{6}
-}
-
-func (m *ChangePin) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_ChangePin.Unmarshal(m, b)
-}
-func (m *ChangePin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_ChangePin.Marshal(b, m, deterministic)
-}
-func (m *ChangePin) XXX_Merge(src proto.Message) {
- xxx_messageInfo_ChangePin.Merge(m, src)
-}
-func (m *ChangePin) XXX_Size() int {
- return xxx_messageInfo_ChangePin.Size(m)
-}
-func (m *ChangePin) XXX_DiscardUnknown() {
- xxx_messageInfo_ChangePin.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ChangePin proto.InternalMessageInfo
-
-func (m *ChangePin) GetRemove() bool {
- if m != nil && m.Remove != nil {
- return *m.Remove
- }
- return false
-}
-
-// *
-// Request: Test if the device is alive, device sends back the message in Success response
-// @start
-// @next Success
-type Ping struct {
- Message *string `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"`
- ButtonProtection *bool `protobuf:"varint,2,opt,name=button_protection,json=buttonProtection" json:"button_protection,omitempty"`
- PinProtection *bool `protobuf:"varint,3,opt,name=pin_protection,json=pinProtection" json:"pin_protection,omitempty"`
- PassphraseProtection *bool `protobuf:"varint,4,opt,name=passphrase_protection,json=passphraseProtection" json:"passphrase_protection,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Ping) Reset() { *m = Ping{} }
-func (m *Ping) String() string { return proto.CompactTextString(m) }
-func (*Ping) ProtoMessage() {}
-func (*Ping) Descriptor() ([]byte, []int) {
- return fileDescriptor_0c720c20d27aa029, []int{7}
-}
-
-func (m *Ping) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Ping.Unmarshal(m, b)
-}
-func (m *Ping) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Ping.Marshal(b, m, deterministic)
-}
-func (m *Ping) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Ping.Merge(m, src)
-}
-func (m *Ping) XXX_Size() int {
- return xxx_messageInfo_Ping.Size(m)
-}
-func (m *Ping) XXX_DiscardUnknown() {
- xxx_messageInfo_Ping.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Ping proto.InternalMessageInfo
-
-func (m *Ping) GetMessage() string {
- if m != nil && m.Message != nil {
- return *m.Message
- }
- return ""
-}
-
-func (m *Ping) GetButtonProtection() bool {
- if m != nil && m.ButtonProtection != nil {
- return *m.ButtonProtection
- }
- return false
-}
-
-func (m *Ping) GetPinProtection() bool {
- if m != nil && m.PinProtection != nil {
- return *m.PinProtection
- }
- return false
-}
-
-func (m *Ping) GetPassphraseProtection() bool {
- if m != nil && m.PassphraseProtection != nil {
- return *m.PassphraseProtection
- }
- return false
-}
-
-// *
-// Request: Abort last operation that required user interaction
-// @start
-// @next Failure
-type Cancel struct {
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Cancel) Reset() { *m = Cancel{} }
-func (m *Cancel) String() string { return proto.CompactTextString(m) }
-func (*Cancel) ProtoMessage() {}
-func (*Cancel) Descriptor() ([]byte, []int) {
- return fileDescriptor_0c720c20d27aa029, []int{8}
-}
-
-func (m *Cancel) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Cancel.Unmarshal(m, b)
-}
-func (m *Cancel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Cancel.Marshal(b, m, deterministic)
-}
-func (m *Cancel) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Cancel.Merge(m, src)
-}
-func (m *Cancel) XXX_Size() int {
- return xxx_messageInfo_Cancel.Size(m)
-}
-func (m *Cancel) XXX_DiscardUnknown() {
- xxx_messageInfo_Cancel.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Cancel proto.InternalMessageInfo
-
-// *
-// Request: Request a sample of random data generated by hardware RNG. May be used for testing.
-// @start
-// @next Entropy
-// @next Failure
-type GetEntropy struct {
- Size *uint32 `protobuf:"varint,1,req,name=size" json:"size,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *GetEntropy) Reset() { *m = GetEntropy{} }
-func (m *GetEntropy) String() string { return proto.CompactTextString(m) }
-func (*GetEntropy) ProtoMessage() {}
-func (*GetEntropy) Descriptor() ([]byte, []int) {
- return fileDescriptor_0c720c20d27aa029, []int{9}
-}
-
-func (m *GetEntropy) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_GetEntropy.Unmarshal(m, b)
-}
-func (m *GetEntropy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_GetEntropy.Marshal(b, m, deterministic)
-}
-func (m *GetEntropy) XXX_Merge(src proto.Message) {
- xxx_messageInfo_GetEntropy.Merge(m, src)
-}
-func (m *GetEntropy) XXX_Size() int {
- return xxx_messageInfo_GetEntropy.Size(m)
-}
-func (m *GetEntropy) XXX_DiscardUnknown() {
- xxx_messageInfo_GetEntropy.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_GetEntropy proto.InternalMessageInfo
-
-func (m *GetEntropy) GetSize() uint32 {
- if m != nil && m.Size != nil {
- return *m.Size
- }
- return 0
-}
-
-// *
-// Response: Reply with random data generated by internal RNG
-// @end
-type Entropy struct {
- Entropy []byte `protobuf:"bytes,1,req,name=entropy" json:"entropy,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Entropy) Reset() { *m = Entropy{} }
-func (m *Entropy) String() string { return proto.CompactTextString(m) }
-func (*Entropy) ProtoMessage() {}
-func (*Entropy) Descriptor() ([]byte, []int) {
- return fileDescriptor_0c720c20d27aa029, []int{10}
-}
-
-func (m *Entropy) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Entropy.Unmarshal(m, b)
-}
-func (m *Entropy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Entropy.Marshal(b, m, deterministic)
-}
-func (m *Entropy) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Entropy.Merge(m, src)
-}
-func (m *Entropy) XXX_Size() int {
- return xxx_messageInfo_Entropy.Size(m)
-}
-func (m *Entropy) XXX_DiscardUnknown() {
- xxx_messageInfo_Entropy.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Entropy proto.InternalMessageInfo
-
-func (m *Entropy) GetEntropy() []byte {
- if m != nil {
- return m.Entropy
- }
- return nil
-}
-
-// *
-// Request: Request device to wipe all sensitive data and settings
-// @start
-// @next Success
-// @next Failure
-type WipeDevice struct {
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *WipeDevice) Reset() { *m = WipeDevice{} }
-func (m *WipeDevice) String() string { return proto.CompactTextString(m) }
-func (*WipeDevice) ProtoMessage() {}
-func (*WipeDevice) Descriptor() ([]byte, []int) {
- return fileDescriptor_0c720c20d27aa029, []int{11}
-}
-
-func (m *WipeDevice) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_WipeDevice.Unmarshal(m, b)
-}
-func (m *WipeDevice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_WipeDevice.Marshal(b, m, deterministic)
-}
-func (m *WipeDevice) XXX_Merge(src proto.Message) {
- xxx_messageInfo_WipeDevice.Merge(m, src)
-}
-func (m *WipeDevice) XXX_Size() int {
- return xxx_messageInfo_WipeDevice.Size(m)
-}
-func (m *WipeDevice) XXX_DiscardUnknown() {
- xxx_messageInfo_WipeDevice.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_WipeDevice proto.InternalMessageInfo
-
-// *
-// Request: Load seed and related internal settings from the computer
-// @start
-// @next Success
-// @next Failure
-type LoadDevice struct {
- Mnemonic *string `protobuf:"bytes,1,opt,name=mnemonic" json:"mnemonic,omitempty"`
- Node *HDNodeType `protobuf:"bytes,2,opt,name=node" json:"node,omitempty"`
- Pin *string `protobuf:"bytes,3,opt,name=pin" json:"pin,omitempty"`
- PassphraseProtection *bool `protobuf:"varint,4,opt,name=passphrase_protection,json=passphraseProtection" json:"passphrase_protection,omitempty"`
- Language *string `protobuf:"bytes,5,opt,name=language,def=english" json:"language,omitempty"`
- Label *string `protobuf:"bytes,6,opt,name=label" json:"label,omitempty"`
- SkipChecksum *bool `protobuf:"varint,7,opt,name=skip_checksum,json=skipChecksum" json:"skip_checksum,omitempty"`
- U2FCounter *uint32 `protobuf:"varint,8,opt,name=u2f_counter,json=u2fCounter" json:"u2f_counter,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *LoadDevice) Reset() { *m = LoadDevice{} }
-func (m *LoadDevice) String() string { return proto.CompactTextString(m) }
-func (*LoadDevice) ProtoMessage() {}
-func (*LoadDevice) Descriptor() ([]byte, []int) {
- return fileDescriptor_0c720c20d27aa029, []int{12}
-}
-
-func (m *LoadDevice) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_LoadDevice.Unmarshal(m, b)
-}
-func (m *LoadDevice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_LoadDevice.Marshal(b, m, deterministic)
-}
-func (m *LoadDevice) XXX_Merge(src proto.Message) {
- xxx_messageInfo_LoadDevice.Merge(m, src)
-}
-func (m *LoadDevice) XXX_Size() int {
- return xxx_messageInfo_LoadDevice.Size(m)
-}
-func (m *LoadDevice) XXX_DiscardUnknown() {
- xxx_messageInfo_LoadDevice.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_LoadDevice proto.InternalMessageInfo
-
-const Default_LoadDevice_Language string = "english"
-
-func (m *LoadDevice) GetMnemonic() string {
- if m != nil && m.Mnemonic != nil {
- return *m.Mnemonic
- }
- return ""
-}
-
-func (m *LoadDevice) GetNode() *HDNodeType {
- if m != nil {
- return m.Node
- }
- return nil
-}
-
-func (m *LoadDevice) GetPin() string {
- if m != nil && m.Pin != nil {
- return *m.Pin
- }
- return ""
-}
-
-func (m *LoadDevice) GetPassphraseProtection() bool {
- if m != nil && m.PassphraseProtection != nil {
- return *m.PassphraseProtection
- }
- return false
-}
-
-func (m *LoadDevice) GetLanguage() string {
- if m != nil && m.Language != nil {
- return *m.Language
- }
- return Default_LoadDevice_Language
-}
-
-func (m *LoadDevice) GetLabel() string {
- if m != nil && m.Label != nil {
- return *m.Label
- }
- return ""
-}
-
-func (m *LoadDevice) GetSkipChecksum() bool {
- if m != nil && m.SkipChecksum != nil {
- return *m.SkipChecksum
- }
- return false
-}
-
-func (m *LoadDevice) GetU2FCounter() uint32 {
- if m != nil && m.U2FCounter != nil {
- return *m.U2FCounter
- }
- return 0
-}
-
-// *
-// Request: Ask device to do initialization involving user interaction
-// @start
-// @next EntropyRequest
-// @next Failure
-type ResetDevice struct {
- DisplayRandom *bool `protobuf:"varint,1,opt,name=display_random,json=displayRandom" json:"display_random,omitempty"`
- Strength *uint32 `protobuf:"varint,2,opt,name=strength,def=256" json:"strength,omitempty"`
- PassphraseProtection *bool `protobuf:"varint,3,opt,name=passphrase_protection,json=passphraseProtection" json:"passphrase_protection,omitempty"`
- PinProtection *bool `protobuf:"varint,4,opt,name=pin_protection,json=pinProtection" json:"pin_protection,omitempty"`
- Language *string `protobuf:"bytes,5,opt,name=language,def=english" json:"language,omitempty"`
- Label *string `protobuf:"bytes,6,opt,name=label" json:"label,omitempty"`
- U2FCounter *uint32 `protobuf:"varint,7,opt,name=u2f_counter,json=u2fCounter" json:"u2f_counter,omitempty"`
- SkipBackup *bool `protobuf:"varint,8,opt,name=skip_backup,json=skipBackup" json:"skip_backup,omitempty"`
- NoBackup *bool `protobuf:"varint,9,opt,name=no_backup,json=noBackup" json:"no_backup,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *ResetDevice) Reset() { *m = ResetDevice{} }
-func (m *ResetDevice) String() string { return proto.CompactTextString(m) }
-func (*ResetDevice) ProtoMessage() {}
-func (*ResetDevice) Descriptor() ([]byte, []int) {
- return fileDescriptor_0c720c20d27aa029, []int{13}
-}
-
-func (m *ResetDevice) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_ResetDevice.Unmarshal(m, b)
-}
-func (m *ResetDevice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_ResetDevice.Marshal(b, m, deterministic)
-}
-func (m *ResetDevice) XXX_Merge(src proto.Message) {
- xxx_messageInfo_ResetDevice.Merge(m, src)
-}
-func (m *ResetDevice) XXX_Size() int {
- return xxx_messageInfo_ResetDevice.Size(m)
-}
-func (m *ResetDevice) XXX_DiscardUnknown() {
- xxx_messageInfo_ResetDevice.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ResetDevice proto.InternalMessageInfo
-
-const Default_ResetDevice_Strength uint32 = 256
-const Default_ResetDevice_Language string = "english"
-
-func (m *ResetDevice) GetDisplayRandom() bool {
- if m != nil && m.DisplayRandom != nil {
- return *m.DisplayRandom
- }
- return false
-}
-
-func (m *ResetDevice) GetStrength() uint32 {
- if m != nil && m.Strength != nil {
- return *m.Strength
- }
- return Default_ResetDevice_Strength
-}
-
-func (m *ResetDevice) GetPassphraseProtection() bool {
- if m != nil && m.PassphraseProtection != nil {
- return *m.PassphraseProtection
- }
- return false
-}
-
-func (m *ResetDevice) GetPinProtection() bool {
- if m != nil && m.PinProtection != nil {
- return *m.PinProtection
- }
- return false
-}
-
-func (m *ResetDevice) GetLanguage() string {
- if m != nil && m.Language != nil {
- return *m.Language
- }
- return Default_ResetDevice_Language
-}
-
-func (m *ResetDevice) GetLabel() string {
- if m != nil && m.Label != nil {
- return *m.Label
- }
- return ""
-}
-
-func (m *ResetDevice) GetU2FCounter() uint32 {
- if m != nil && m.U2FCounter != nil {
- return *m.U2FCounter
- }
- return 0
-}
-
-func (m *ResetDevice) GetSkipBackup() bool {
- if m != nil && m.SkipBackup != nil {
- return *m.SkipBackup
- }
- return false
-}
-
-func (m *ResetDevice) GetNoBackup() bool {
- if m != nil && m.NoBackup != nil {
- return *m.NoBackup
- }
- return false
-}
-
-// *
-// Request: Perform backup of the device seed if not backed up using ResetDevice
-// @start
-// @next Success
-type BackupDevice struct {
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *BackupDevice) Reset() { *m = BackupDevice{} }
-func (m *BackupDevice) String() string { return proto.CompactTextString(m) }
-func (*BackupDevice) ProtoMessage() {}
-func (*BackupDevice) Descriptor() ([]byte, []int) {
- return fileDescriptor_0c720c20d27aa029, []int{14}
-}
-
-func (m *BackupDevice) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_BackupDevice.Unmarshal(m, b)
-}
-func (m *BackupDevice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_BackupDevice.Marshal(b, m, deterministic)
-}
-func (m *BackupDevice) XXX_Merge(src proto.Message) {
- xxx_messageInfo_BackupDevice.Merge(m, src)
-}
-func (m *BackupDevice) XXX_Size() int {
- return xxx_messageInfo_BackupDevice.Size(m)
-}
-func (m *BackupDevice) XXX_DiscardUnknown() {
- xxx_messageInfo_BackupDevice.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_BackupDevice proto.InternalMessageInfo
-
-// *
-// Response: Ask for additional entropy from host computer
-// @next EntropyAck
-type EntropyRequest struct {
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *EntropyRequest) Reset() { *m = EntropyRequest{} }
-func (m *EntropyRequest) String() string { return proto.CompactTextString(m) }
-func (*EntropyRequest) ProtoMessage() {}
-func (*EntropyRequest) Descriptor() ([]byte, []int) {
- return fileDescriptor_0c720c20d27aa029, []int{15}
-}
-
-func (m *EntropyRequest) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_EntropyRequest.Unmarshal(m, b)
-}
-func (m *EntropyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_EntropyRequest.Marshal(b, m, deterministic)
-}
-func (m *EntropyRequest) XXX_Merge(src proto.Message) {
- xxx_messageInfo_EntropyRequest.Merge(m, src)
-}
-func (m *EntropyRequest) XXX_Size() int {
- return xxx_messageInfo_EntropyRequest.Size(m)
-}
-func (m *EntropyRequest) XXX_DiscardUnknown() {
- xxx_messageInfo_EntropyRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EntropyRequest proto.InternalMessageInfo
-
-// *
-// Request: Provide additional entropy for seed generation function
-// @next Success
-type EntropyAck struct {
- Entropy []byte `protobuf:"bytes,1,opt,name=entropy" json:"entropy,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *EntropyAck) Reset() { *m = EntropyAck{} }
-func (m *EntropyAck) String() string { return proto.CompactTextString(m) }
-func (*EntropyAck) ProtoMessage() {}
-func (*EntropyAck) Descriptor() ([]byte, []int) {
- return fileDescriptor_0c720c20d27aa029, []int{16}
-}
-
-func (m *EntropyAck) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_EntropyAck.Unmarshal(m, b)
-}
-func (m *EntropyAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_EntropyAck.Marshal(b, m, deterministic)
-}
-func (m *EntropyAck) XXX_Merge(src proto.Message) {
- xxx_messageInfo_EntropyAck.Merge(m, src)
-}
-func (m *EntropyAck) XXX_Size() int {
- return xxx_messageInfo_EntropyAck.Size(m)
-}
-func (m *EntropyAck) XXX_DiscardUnknown() {
- xxx_messageInfo_EntropyAck.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EntropyAck proto.InternalMessageInfo
-
-func (m *EntropyAck) GetEntropy() []byte {
- if m != nil {
- return m.Entropy
- }
- return nil
-}
-
-// *
-// Request: Start recovery workflow asking user for specific words of mnemonic
-// Used to recovery device safely even on untrusted computer.
-// @start
-// @next WordRequest
-type RecoveryDevice struct {
- WordCount *uint32 `protobuf:"varint,1,opt,name=word_count,json=wordCount" json:"word_count,omitempty"`
- PassphraseProtection *bool `protobuf:"varint,2,opt,name=passphrase_protection,json=passphraseProtection" json:"passphrase_protection,omitempty"`
- PinProtection *bool `protobuf:"varint,3,opt,name=pin_protection,json=pinProtection" json:"pin_protection,omitempty"`
- Language *string `protobuf:"bytes,4,opt,name=language,def=english" json:"language,omitempty"`
- Label *string `protobuf:"bytes,5,opt,name=label" json:"label,omitempty"`
- EnforceWordlist *bool `protobuf:"varint,6,opt,name=enforce_wordlist,json=enforceWordlist" json:"enforce_wordlist,omitempty"`
- // 7 reserved for unused recovery method
- Type *RecoveryDevice_RecoveryDeviceType `protobuf:"varint,8,opt,name=type,enum=hw.trezor.messages.management.RecoveryDevice_RecoveryDeviceType" json:"type,omitempty"`
- U2FCounter *uint32 `protobuf:"varint,9,opt,name=u2f_counter,json=u2fCounter" json:"u2f_counter,omitempty"`
- DryRun *bool `protobuf:"varint,10,opt,name=dry_run,json=dryRun" json:"dry_run,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *RecoveryDevice) Reset() { *m = RecoveryDevice{} }
-func (m *RecoveryDevice) String() string { return proto.CompactTextString(m) }
-func (*RecoveryDevice) ProtoMessage() {}
-func (*RecoveryDevice) Descriptor() ([]byte, []int) {
- return fileDescriptor_0c720c20d27aa029, []int{17}
-}
-
-func (m *RecoveryDevice) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_RecoveryDevice.Unmarshal(m, b)
-}
-func (m *RecoveryDevice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_RecoveryDevice.Marshal(b, m, deterministic)
-}
-func (m *RecoveryDevice) XXX_Merge(src proto.Message) {
- xxx_messageInfo_RecoveryDevice.Merge(m, src)
-}
-func (m *RecoveryDevice) XXX_Size() int {
- return xxx_messageInfo_RecoveryDevice.Size(m)
-}
-func (m *RecoveryDevice) XXX_DiscardUnknown() {
- xxx_messageInfo_RecoveryDevice.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_RecoveryDevice proto.InternalMessageInfo
-
-const Default_RecoveryDevice_Language string = "english"
-
-func (m *RecoveryDevice) GetWordCount() uint32 {
- if m != nil && m.WordCount != nil {
- return *m.WordCount
- }
- return 0
-}
-
-func (m *RecoveryDevice) GetPassphraseProtection() bool {
- if m != nil && m.PassphraseProtection != nil {
- return *m.PassphraseProtection
- }
- return false
-}
-
-func (m *RecoveryDevice) GetPinProtection() bool {
- if m != nil && m.PinProtection != nil {
- return *m.PinProtection
- }
- return false
-}
-
-func (m *RecoveryDevice) GetLanguage() string {
- if m != nil && m.Language != nil {
- return *m.Language
- }
- return Default_RecoveryDevice_Language
-}
-
-func (m *RecoveryDevice) GetLabel() string {
- if m != nil && m.Label != nil {
- return *m.Label
- }
- return ""
-}
-
-func (m *RecoveryDevice) GetEnforceWordlist() bool {
- if m != nil && m.EnforceWordlist != nil {
- return *m.EnforceWordlist
- }
- return false
-}
-
-func (m *RecoveryDevice) GetType() RecoveryDevice_RecoveryDeviceType {
- if m != nil && m.Type != nil {
- return *m.Type
- }
- return RecoveryDevice_RecoveryDeviceType_ScrambledWords
-}
-
-func (m *RecoveryDevice) GetU2FCounter() uint32 {
- if m != nil && m.U2FCounter != nil {
- return *m.U2FCounter
- }
- return 0
-}
-
-func (m *RecoveryDevice) GetDryRun() bool {
- if m != nil && m.DryRun != nil {
- return *m.DryRun
- }
- return false
-}
-
-// *
-// Response: Device is waiting for user to enter word of the mnemonic
-// Its position is shown only on device's internal display.
-// @next WordAck
-type WordRequest struct {
- Type *WordRequest_WordRequestType `protobuf:"varint,1,opt,name=type,enum=hw.trezor.messages.management.WordRequest_WordRequestType" json:"type,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *WordRequest) Reset() { *m = WordRequest{} }
-func (m *WordRequest) String() string { return proto.CompactTextString(m) }
-func (*WordRequest) ProtoMessage() {}
-func (*WordRequest) Descriptor() ([]byte, []int) {
- return fileDescriptor_0c720c20d27aa029, []int{18}
-}
-
-func (m *WordRequest) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_WordRequest.Unmarshal(m, b)
-}
-func (m *WordRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_WordRequest.Marshal(b, m, deterministic)
-}
-func (m *WordRequest) XXX_Merge(src proto.Message) {
- xxx_messageInfo_WordRequest.Merge(m, src)
-}
-func (m *WordRequest) XXX_Size() int {
- return xxx_messageInfo_WordRequest.Size(m)
-}
-func (m *WordRequest) XXX_DiscardUnknown() {
- xxx_messageInfo_WordRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_WordRequest proto.InternalMessageInfo
-
-func (m *WordRequest) GetType() WordRequest_WordRequestType {
- if m != nil && m.Type != nil {
- return *m.Type
- }
- return WordRequest_WordRequestType_Plain
-}
-
-// *
-// Request: Computer replies with word from the mnemonic
-// @next WordRequest
-// @next Success
-// @next Failure
-type WordAck struct {
- Word *string `protobuf:"bytes,1,req,name=word" json:"word,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *WordAck) Reset() { *m = WordAck{} }
-func (m *WordAck) String() string { return proto.CompactTextString(m) }
-func (*WordAck) ProtoMessage() {}
-func (*WordAck) Descriptor() ([]byte, []int) {
- return fileDescriptor_0c720c20d27aa029, []int{19}
-}
-
-func (m *WordAck) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_WordAck.Unmarshal(m, b)
-}
-func (m *WordAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_WordAck.Marshal(b, m, deterministic)
-}
-func (m *WordAck) XXX_Merge(src proto.Message) {
- xxx_messageInfo_WordAck.Merge(m, src)
-}
-func (m *WordAck) XXX_Size() int {
- return xxx_messageInfo_WordAck.Size(m)
-}
-func (m *WordAck) XXX_DiscardUnknown() {
- xxx_messageInfo_WordAck.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_WordAck proto.InternalMessageInfo
-
-func (m *WordAck) GetWord() string {
- if m != nil && m.Word != nil {
- return *m.Word
- }
- return ""
-}
-
-// *
-// Request: Set U2F counter
-// @start
-// @next Success
-type SetU2FCounter struct {
- U2FCounter *uint32 `protobuf:"varint,1,opt,name=u2f_counter,json=u2fCounter" json:"u2f_counter,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *SetU2FCounter) Reset() { *m = SetU2FCounter{} }
-func (m *SetU2FCounter) String() string { return proto.CompactTextString(m) }
-func (*SetU2FCounter) ProtoMessage() {}
-func (*SetU2FCounter) Descriptor() ([]byte, []int) {
- return fileDescriptor_0c720c20d27aa029, []int{20}
-}
-
-func (m *SetU2FCounter) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_SetU2FCounter.Unmarshal(m, b)
-}
-func (m *SetU2FCounter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_SetU2FCounter.Marshal(b, m, deterministic)
-}
-func (m *SetU2FCounter) XXX_Merge(src proto.Message) {
- xxx_messageInfo_SetU2FCounter.Merge(m, src)
-}
-func (m *SetU2FCounter) XXX_Size() int {
- return xxx_messageInfo_SetU2FCounter.Size(m)
-}
-func (m *SetU2FCounter) XXX_DiscardUnknown() {
- xxx_messageInfo_SetU2FCounter.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_SetU2FCounter proto.InternalMessageInfo
-
-func (m *SetU2FCounter) GetU2FCounter() uint32 {
- if m != nil && m.U2FCounter != nil {
- return *m.U2FCounter
- }
- return 0
-}
-
-func init() {
- proto.RegisterEnum("hw.trezor.messages.management.ApplySettings_PassphraseSourceType", ApplySettings_PassphraseSourceType_name, ApplySettings_PassphraseSourceType_value)
- proto.RegisterEnum("hw.trezor.messages.management.RecoveryDevice_RecoveryDeviceType", RecoveryDevice_RecoveryDeviceType_name, RecoveryDevice_RecoveryDeviceType_value)
- proto.RegisterEnum("hw.trezor.messages.management.WordRequest_WordRequestType", WordRequest_WordRequestType_name, WordRequest_WordRequestType_value)
- proto.RegisterType((*Initialize)(nil), "hw.trezor.messages.management.Initialize")
- proto.RegisterType((*GetFeatures)(nil), "hw.trezor.messages.management.GetFeatures")
- proto.RegisterType((*Features)(nil), "hw.trezor.messages.management.Features")
- proto.RegisterType((*ClearSession)(nil), "hw.trezor.messages.management.ClearSession")
- proto.RegisterType((*ApplySettings)(nil), "hw.trezor.messages.management.ApplySettings")
- proto.RegisterType((*ApplyFlags)(nil), "hw.trezor.messages.management.ApplyFlags")
- proto.RegisterType((*ChangePin)(nil), "hw.trezor.messages.management.ChangePin")
- proto.RegisterType((*Ping)(nil), "hw.trezor.messages.management.Ping")
- proto.RegisterType((*Cancel)(nil), "hw.trezor.messages.management.Cancel")
- proto.RegisterType((*GetEntropy)(nil), "hw.trezor.messages.management.GetEntropy")
- proto.RegisterType((*Entropy)(nil), "hw.trezor.messages.management.Entropy")
- proto.RegisterType((*WipeDevice)(nil), "hw.trezor.messages.management.WipeDevice")
- proto.RegisterType((*LoadDevice)(nil), "hw.trezor.messages.management.LoadDevice")
- proto.RegisterType((*ResetDevice)(nil), "hw.trezor.messages.management.ResetDevice")
- proto.RegisterType((*BackupDevice)(nil), "hw.trezor.messages.management.BackupDevice")
- proto.RegisterType((*EntropyRequest)(nil), "hw.trezor.messages.management.EntropyRequest")
- proto.RegisterType((*EntropyAck)(nil), "hw.trezor.messages.management.EntropyAck")
- proto.RegisterType((*RecoveryDevice)(nil), "hw.trezor.messages.management.RecoveryDevice")
- proto.RegisterType((*WordRequest)(nil), "hw.trezor.messages.management.WordRequest")
- proto.RegisterType((*WordAck)(nil), "hw.trezor.messages.management.WordAck")
- proto.RegisterType((*SetU2FCounter)(nil), "hw.trezor.messages.management.SetU2FCounter")
-}
-
-func init() { proto.RegisterFile("messages-management.proto", fileDescriptor_0c720c20d27aa029) }
-
-var fileDescriptor_0c720c20d27aa029 = []byte{
- // 1393 bytes of a gzipped FileDescriptorProto
- 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x57, 0xdd, 0x6e, 0xdb, 0xc8,
- 0x15, 0x8e, 0x7e, 0x62, 0x49, 0xc7, 0xfa, 0xcb, 0xd4, 0x8e, 0xe9, 0xb8, 0x6e, 0x1c, 0xba, 0x6e,
- 0x12, 0x04, 0x15, 0x0a, 0x17, 0x09, 0x90, 0x5c, 0x14, 0x75, 0xec, 0xfc, 0x21, 0x71, 0x6a, 0xd0,
- 0x6e, 0x02, 0xf4, 0x86, 0x18, 0x91, 0x47, 0xd2, 0xd4, 0xe4, 0x0c, 0xcb, 0x19, 0xda, 0x55, 0x5e,
- 0x60, 0x6f, 0xf6, 0x45, 0x16, 0xfb, 0x1c, 0x7b, 0xb5, 0xcf, 0xb0, 0xef, 0xb2, 0x98, 0x19, 0x52,
- 0xa2, 0x65, 0x3b, 0x46, 0x76, 0xef, 0xe6, 0x7c, 0xe7, 0xe3, 0x68, 0xce, 0x77, 0xbe, 0x39, 0x63,
- 0xc3, 0x7a, 0x8c, 0x52, 0xd2, 0x31, 0xca, 0xbf, 0xc6, 0x94, 0xd3, 0x31, 0xc6, 0xc8, 0xd5, 0x20,
- 0x49, 0x85, 0x12, 0x64, 0x73, 0x72, 0x3e, 0x50, 0x29, 0x7e, 0x11, 0xe9, 0xa0, 0x20, 0x0d, 0xe6,
- 0xa4, 0x7b, 0xab, 0xb3, 0x2f, 0x03, 0x11, 0xc7, 0x82, 0xdb, 0xaf, 0xdc, 0xf7, 0x00, 0xef, 0x38,
- 0x53, 0x8c, 0x46, 0xec, 0x0b, 0x92, 0x15, 0xb8, 0x2d, 0x15, 0x55, 0xe8, 0x54, 0xb6, 0x2a, 0x8f,
- 0xda, 0x9e, 0x0d, 0xc8, 0x43, 0xe8, 0xc9, 0x53, 0x96, 0xf8, 0x09, 0x95, 0x32, 0x99, 0xa4, 0x54,
- 0xa2, 0x53, 0xdd, 0xaa, 0x3c, 0x6a, 0x7a, 0x5d, 0x0d, 0x1f, 0xcd, 0x50, 0xb7, 0x03, 0xcb, 0x6f,
- 0x50, 0xbd, 0x46, 0xaa, 0xb2, 0x14, 0xa5, 0xfb, 0x7d, 0x03, 0x9a, 0x45, 0x40, 0xee, 0xc2, 0xd2,
- 0x19, 0xf2, 0x50, 0xa4, 0x66, 0xef, 0x96, 0x97, 0x47, 0x64, 0x1b, 0x3a, 0x31, 0xfd, 0xaf, 0x48,
- 0xfd, 0x33, 0x4c, 0x25, 0x13, 0xdc, 0x6c, 0xdd, 0xf1, 0xda, 0x06, 0xfc, 0x64, 0x31, 0x43, 0x62,
- 0xbc, 0x44, 0xaa, 0xe5, 0x24, 0x0d, 0x96, 0x48, 0x09, 0x55, 0xc1, 0x64, 0x46, 0xaa, 0x5b, 0x92,
- 0x01, 0x0b, 0xd2, 0x43, 0xe8, 0x0d, 0x85, 0x50, 0x91, 0xa0, 0x21, 0xa6, 0x7e, 0x2c, 0x42, 0x74,
- 0x6e, 0xdb, 0x5a, 0xe6, 0xf0, 0xa1, 0x08, 0x91, 0x6c, 0x40, 0x2b, 0xc4, 0x33, 0x16, 0xa0, 0xcf,
- 0x42, 0x67, 0xc9, 0x1c, 0xb9, 0x69, 0x81, 0x77, 0x21, 0xd9, 0x81, 0x6e, 0xc2, 0xb8, 0xaf, 0x25,
- 0xc4, 0x40, 0xe9, 0xdf, 0x6a, 0x98, 0x4d, 0x3a, 0x09, 0xe3, 0x47, 0x33, 0x90, 0xfc, 0x1d, 0x56,
- 0xe7, 0x9a, 0x95, 0xd9, 0x4d, 0xc3, 0x5e, 0x99, 0x27, 0x4b, 0x1f, 0xdd, 0x83, 0x66, 0x44, 0xf9,
- 0x38, 0xa3, 0x63, 0x74, 0x5a, 0xf6, 0x77, 0x8b, 0x58, 0xf7, 0x27, 0xa2, 0x43, 0x8c, 0x1c, 0x30,
- 0x09, 0x1b, 0x90, 0x2d, 0x58, 0x66, 0xb3, 0x1e, 0x86, 0x4e, 0xdb, 0x6c, 0x5e, 0x86, 0xf4, 0x9e,
- 0x29, 0x9e, 0x31, 0xa3, 0x4a, 0xc7, 0xb4, 0x76, 0x16, 0x2f, 0x28, 0x32, 0xa1, 0x72, 0xe2, 0x74,
- 0x0d, 0xa5, 0xa4, 0xc8, 0x5b, 0x2a, 0x27, 0x7a, 0x13, 0x16, 0x27, 0x22, 0x55, 0x18, 0x3a, 0x3d,
- 0xf3, 0x1b, 0xb3, 0x98, 0x6c, 0x02, 0x68, 0x41, 0x02, 0x1a, 0x4c, 0x30, 0x74, 0xfa, 0x26, 0xdb,
- 0x4a, 0x18, 0xdf, 0x37, 0x00, 0x79, 0x02, 0x77, 0x4a, 0x42, 0xe4, 0xac, 0x3b, 0x86, 0xd5, 0x9f,
- 0x27, 0x72, 0xf2, 0x63, 0xe8, 0x8f, 0x58, 0x1a, 0x9f, 0xd3, 0x54, 0x6b, 0x86, 0x12, 0xb9, 0x72,
- 0x88, 0xe1, 0xf6, 0x0a, 0xfc, 0xc8, 0xc2, 0xe4, 0x01, 0xb4, 0x39, 0x62, 0x28, 0xfd, 0x21, 0x0d,
- 0x4e, 0xb3, 0xc4, 0xf9, 0x83, 0x2d, 0xdd, 0x60, 0x2f, 0x0d, 0xa4, 0x25, 0x1b, 0x45, 0x74, 0x2c,
- 0x9d, 0x15, 0xe3, 0x06, 0x1b, 0x68, 0x54, 0xf7, 0x3e, 0x72, 0x56, 0xad, 0x90, 0x26, 0x20, 0xeb,
- 0xd0, 0x1c, 0x9d, 0xfb, 0xc6, 0x79, 0xce, 0x5d, 0x43, 0x6f, 0x8c, 0xce, 0x0f, 0x75, 0x58, 0xa4,
- 0xb4, 0xdf, 0x9c, 0xb5, 0x59, 0x4a, 0x87, 0x79, 0xca, 0xb8, 0xcc, 0x71, 0x8a, 0xd4, 0x91, 0x0e,
- 0xb5, 0x89, 0x46, 0xe7, 0x7e, 0xee, 0xfb, 0x75, 0xdb, 0xcc, 0xd1, 0xf9, 0x27, 0xeb, 0xfc, 0x3f,
- 0x43, 0x77, 0x96, 0xf4, 0x4f, 0x71, 0x2a, 0x9d, 0x7b, 0x46, 0xf7, 0x76, 0xc1, 0x78, 0x8f, 0x53,
- 0xa9, 0xa5, 0xcb, 0xf8, 0x88, 0x71, 0x26, 0x27, 0x18, 0x16, 0x75, 0x6e, 0x58, 0xe9, 0xe6, 0x89,
- 0xbc, 0xd8, 0x0d, 0x68, 0x71, 0x51, 0x90, 0xfe, 0x68, 0x7b, 0xc4, 0x85, 0x4d, 0xba, 0x5d, 0x68,
- 0xef, 0x47, 0x48, 0xd3, 0x63, 0x94, 0xba, 0xf1, 0xee, 0x77, 0x35, 0xe8, 0xec, 0x25, 0x49, 0x34,
- 0x3d, 0x46, 0xa5, 0x18, 0x1f, 0xcb, 0x0b, 0xd6, 0xab, 0x5c, 0x67, 0xbd, 0x6a, 0xd9, 0x7a, 0x3b,
- 0xd0, 0xcd, 0xb4, 0xb5, 0xe7, 0x93, 0xa1, 0x66, 0x2f, 0x42, 0x26, 0x71, 0x3e, 0x18, 0xc8, 0x9f,
- 0x00, 0x26, 0x22, 0x46, 0x19, 0xa4, 0x88, 0xf6, 0x5e, 0xb6, 0xbd, 0x12, 0x42, 0xf8, 0x05, 0x7f,
- 0x48, 0x91, 0xa5, 0x81, 0xbd, 0x97, 0xdd, 0xdd, 0xbd, 0xc1, 0x57, 0xe7, 0xda, 0xe0, 0x42, 0x05,
- 0x83, 0xf9, 0x6f, 0x1e, 0x9b, 0x4d, 0x4e, 0xa6, 0x09, 0x96, 0x2d, 0x66, 0x51, 0xf2, 0x04, 0x08,
- 0xcd, 0x94, 0xf0, 0x23, 0x11, 0x9c, 0xfa, 0x21, 0x46, 0x74, 0xea, 0xc7, 0xd2, 0xdc, 0xf2, 0x8e,
- 0xd7, 0xd3, 0x99, 0x0f, 0x22, 0x38, 0x3d, 0xd0, 0xf8, 0xa1, 0xd4, 0x7e, 0x0c, 0x99, 0x4c, 0x34,
- 0x29, 0x15, 0x8a, 0xce, 0xae, 0x7b, 0xc7, 0xeb, 0xe5, 0xb8, 0x97, 0xc3, 0xee, 0x53, 0x58, 0xb9,
- 0xea, 0x04, 0xa4, 0x01, 0xb5, 0xbd, 0xe3, 0xf7, 0xfd, 0x5b, 0x04, 0x60, 0xe9, 0xe0, 0xd5, 0xa7,
- 0x77, 0xfb, 0xaf, 0xfa, 0x15, 0xd2, 0x84, 0xfa, 0xdb, 0x7f, 0x1d, 0x9f, 0xf4, 0xab, 0xae, 0x0b,
- 0x60, 0xca, 0x78, 0x5d, 0x78, 0xd3, 0x3a, 0xb6, 0x52, 0x72, 0xac, 0xbb, 0x0d, 0xad, 0xfd, 0x09,
- 0xe5, 0x63, 0x3c, 0x62, 0x5c, 0x0f, 0xd3, 0x14, 0x63, 0x71, 0x66, 0xdb, 0xd4, 0xf4, 0xf2, 0xc8,
- 0xfd, 0xa1, 0x02, 0xf5, 0x23, 0xc6, 0xc7, 0xc4, 0x81, 0x46, 0x2e, 0x56, 0xde, 0xc8, 0x22, 0xd4,
- 0x7e, 0x1a, 0x66, 0x4a, 0x89, 0x0b, 0xd3, 0xcb, 0x8e, 0xf3, 0xbe, 0x4d, 0x94, 0x66, 0xd1, 0xe5,
- 0x39, 0x57, 0xfb, 0xa6, 0x39, 0x57, 0xbf, 0x7e, 0xce, 0xb9, 0x4d, 0x58, 0xda, 0xa7, 0x3c, 0xc0,
- 0xc8, 0xdd, 0x02, 0x78, 0x83, 0xea, 0x15, 0x57, 0xa9, 0x48, 0xa6, 0x84, 0x40, 0x5d, 0xb2, 0x2f,
- 0xfa, 0xdc, 0xd5, 0x47, 0x1d, 0xcf, 0xac, 0xdd, 0x6d, 0x68, 0x14, 0x69, 0x07, 0x1a, 0x68, 0x97,
- 0x86, 0xd1, 0xf6, 0x8a, 0xd0, 0x6d, 0x03, 0x7c, 0x66, 0x09, 0x1e, 0x98, 0x21, 0xed, 0xfe, 0x58,
- 0x05, 0xf8, 0x20, 0x68, 0x68, 0x43, 0x6d, 0xed, 0x98, 0x63, 0x2c, 0x38, 0x0b, 0x0a, 0x6b, 0x17,
- 0x31, 0x79, 0x0e, 0x75, 0xae, 0x1f, 0x02, 0xad, 0xc2, 0xf2, 0xee, 0xce, 0x55, 0x86, 0xcb, 0xdf,
- 0xcc, 0xb7, 0x07, 0x1f, 0x45, 0x68, 0x4d, 0x65, 0x3e, 0x21, 0x7d, 0xa8, 0x25, 0xcc, 0xaa, 0xd2,
- 0xf2, 0xf4, 0xf2, 0x37, 0x69, 0x41, 0xb6, 0x4b, 0x17, 0x4f, 0xdb, 0xbe, 0xf5, 0xa2, 0x81, 0x7c,
- 0x1c, 0x31, 0x39, 0xb9, 0xea, 0x06, 0x2e, 0x95, 0x6f, 0xe0, 0x36, 0x74, 0xcc, 0xe3, 0x1c, 0x4c,
- 0x30, 0x38, 0x95, 0x59, 0x9c, 0xbf, 0x44, 0x6d, 0x0d, 0xee, 0xe7, 0x18, 0xb9, 0x0f, 0xcb, 0xd9,
- 0xee, 0xc8, 0x0f, 0x44, 0xc6, 0x15, 0xa6, 0xe6, 0xf9, 0xe9, 0x78, 0x90, 0xed, 0x8e, 0xf6, 0x2d,
- 0xe2, 0xfe, 0x5c, 0x85, 0x65, 0x0f, 0x25, 0xaa, 0x5c, 0xae, 0x1d, 0xe8, 0xce, 0x3c, 0x4f, 0x79,
- 0x28, 0xe2, 0xdc, 0x68, 0x9d, 0xc2, 0xf1, 0x06, 0x24, 0xf7, 0xa1, 0x29, 0x55, 0x8a, 0x7c, 0xac,
- 0x26, 0xf6, 0xdd, 0x7e, 0x51, 0xdb, 0x7d, 0xfa, 0xcc, 0x9b, 0x81, 0xd7, 0xab, 0x51, 0xfb, 0x8a,
- 0x1a, 0x97, 0x5d, 0x57, 0xbf, 0xca, 0x75, 0xbf, 0x43, 0xb4, 0x05, 0x3d, 0x1a, 0x8b, 0x7a, 0x68,
- 0x82, 0x51, 0x35, 0x1f, 0xa5, 0xf6, 0xbd, 0x06, 0x0d, 0x5d, 0x35, 0x69, 0x5b, 0x97, 0x27, 0xad,
- 0x5d, 0xe5, 0x5e, 0xec, 0x43, 0x37, 0xb7, 0xaf, 0x87, 0xff, 0xcb, 0x50, 0x2a, 0xf7, 0x2f, 0x00,
- 0x39, 0xb2, 0x17, 0x9c, 0x5e, 0xf4, 0x74, 0xa5, 0xec, 0xe9, 0x5f, 0x6a, 0xd0, 0xf5, 0x30, 0x10,
- 0x67, 0x98, 0x4e, 0xf3, 0xd6, 0x6c, 0x02, 0x9c, 0x8b, 0x34, 0xb4, 0x87, 0xcf, 0x67, 0x44, 0x4b,
- 0x23, 0xe6, 0xec, 0xd7, 0x2b, 0x5e, 0xfd, 0x26, 0xc5, 0x6b, 0x37, 0x29, 0x5e, 0xbf, 0x51, 0xf1,
- 0xdb, 0x65, 0xc5, 0x1f, 0x43, 0x1f, 0xf9, 0x48, 0xa4, 0x01, 0xfa, 0xfa, 0xac, 0x11, 0x93, 0xca,
- 0xb4, 0xa4, 0xe9, 0xf5, 0x72, 0xfc, 0x73, 0x0e, 0x93, 0x13, 0xa8, 0xab, 0x69, 0x82, 0x46, 0xf4,
- 0xee, 0xee, 0x3f, 0x6f, 0x98, 0xff, 0x17, 0xd5, 0x59, 0x08, 0xed, 0x4d, 0xd5, 0xbb, 0x2d, 0xb6,
- 0xbc, 0x75, 0xa9, 0xe5, 0x6b, 0xd0, 0x08, 0xd3, 0xa9, 0x9f, 0x66, 0xdc, 0xfc, 0x75, 0xd5, 0xf4,
- 0x96, 0xc2, 0x74, 0xea, 0x65, 0xdc, 0xfd, 0x0f, 0x90, 0xcb, 0xbb, 0x92, 0x1d, 0x78, 0x70, 0x19,
- 0xf5, 0x8f, 0x83, 0x94, 0xc6, 0xc3, 0x08, 0x43, 0x5d, 0x8d, 0xec, 0xdf, 0x22, 0x9b, 0xb0, 0x7e,
- 0x05, 0xed, 0x90, 0xaa, 0x94, 0xfd, 0xbf, 0x5f, 0x71, 0x7f, 0xaa, 0xc0, 0xb2, 0xa6, 0xe6, 0xbe,
- 0x20, 0x1f, 0xf3, 0xda, 0x2b, 0xa6, 0xf6, 0x17, 0x37, 0xd4, 0x5e, 0xfa, 0xb2, 0xbc, 0x9e, 0x57,
- 0xed, 0x8e, 0xa0, 0xb7, 0x90, 0x20, 0xeb, 0xb0, 0xba, 0x00, 0xf9, 0x47, 0x11, 0x65, 0xbc, 0x7f,
- 0x8b, 0x6c, 0xc0, 0xda, 0x62, 0xca, 0x9e, 0xf4, 0x79, 0xbf, 0x72, 0x7d, 0xf2, 0x59, 0xbf, 0xea,
- 0x6e, 0x42, 0x43, 0x27, 0xb5, 0x99, 0x09, 0xd4, 0x75, 0x87, 0xcd, 0x74, 0x6e, 0x79, 0x66, 0xed,
- 0xfe, 0x0d, 0x3a, 0xc7, 0xa8, 0xfe, 0xbd, 0xfb, 0xba, 0x74, 0xbf, 0xca, 0xdd, 0xa8, 0x2c, 0x76,
- 0xe3, 0xe5, 0x3f, 0x60, 0x3b, 0x10, 0xf1, 0x40, 0x52, 0x25, 0xe4, 0x84, 0x45, 0x74, 0x28, 0x0b,
- 0x21, 0x22, 0x36, 0xb4, 0xff, 0xbb, 0x0c, 0xb3, 0xd1, 0xcb, 0xb5, 0x13, 0x03, 0x1e, 0x5a, 0x71,
- 0x0e, 0x67, 0xd2, 0xfc, 0x1a, 0x00, 0x00, 0xff, 0xff, 0xd7, 0x6e, 0xfc, 0x59, 0x29, 0x0d, 0x00,
- 0x00,
-}
diff --git a/accounts/usbwallet/trezor/messages-management.proto b/accounts/usbwallet/trezor/messages-management.proto
deleted file mode 100644
index 0ab825a1bc..0000000000
--- a/accounts/usbwallet/trezor/messages-management.proto
+++ /dev/null
@@ -1,289 +0,0 @@
-// This file originates from the SatoshiLabs Trezor `common` repository at:
-// https://github.com/trezor/trezor-common/blob/master/protob/messages-management.proto
-// dated 28.05.2019, commit 893fd219d4a01bcffa0cd9cfa631856371ec5aa9.
-
-syntax = "proto2";
-package hw.trezor.messages.management;
-
-// Sugar for easier handling in Java
-option java_package = "com.satoshilabs.trezor.lib.protobuf";
-option java_outer_classname = "TrezorMessageManagement";
-
-import "messages-common.proto";
-
-/**
- * Request: Reset device to default state and ask for device details
- * @start
- * @next Features
- */
-message Initialize {
- optional bytes state = 1; // assumed device state, clear session if set and different
- optional bool skip_passphrase = 2; // this session should always assume empty passphrase
-}
-
-/**
- * Request: Ask for device details (no device reset)
- * @start
- * @next Features
- */
-message GetFeatures {
-}
-
-/**
- * Response: Reports various information about the device
- * @end
- */
-message Features {
- optional string vendor = 1; // name of the manufacturer, e.g. "trezor.io"
- optional uint32 major_version = 2; // major version of the firmware/bootloader, e.g. 1
- optional uint32 minor_version = 3; // minor version of the firmware/bootloader, e.g. 0
- optional uint32 patch_version = 4; // patch version of the firmware/bootloader, e.g. 0
- optional bool bootloader_mode = 5; // is device in bootloader mode?
- optional string device_id = 6; // device's unique identifier
- optional bool pin_protection = 7; // is device protected by PIN?
- optional bool passphrase_protection = 8; // is node/mnemonic encrypted using passphrase?
- optional string language = 9; // device language
- optional string label = 10; // device description label
- optional bool initialized = 12; // does device contain seed?
- optional bytes revision = 13; // SCM revision of firmware
- optional bytes bootloader_hash = 14; // hash of the bootloader
- optional bool imported = 15; // was storage imported from an external source?
- optional bool pin_cached = 16; // is PIN already cached in session?
- optional bool passphrase_cached = 17; // is passphrase already cached in session?
- optional bool firmware_present = 18; // is valid firmware loaded?
- optional bool needs_backup = 19; // does storage need backup? (equals to Storage.needs_backup)
- optional uint32 flags = 20; // device flags (equals to Storage.flags)
- optional string model = 21; // device hardware model
- optional uint32 fw_major = 22; // reported firmware version if in bootloader mode
- optional uint32 fw_minor = 23; // reported firmware version if in bootloader mode
- optional uint32 fw_patch = 24; // reported firmware version if in bootloader mode
- optional string fw_vendor = 25; // reported firmware vendor if in bootloader mode
- optional bytes fw_vendor_keys = 26; // reported firmware vendor keys (their hash)
- optional bool unfinished_backup = 27; // report unfinished backup (equals to Storage.unfinished_backup)
- optional bool no_backup = 28; // report no backup (equals to Storage.no_backup)
-}
-
-/**
- * Request: clear session (removes cached PIN, passphrase, etc).
- * @start
- * @next Success
- */
-message ClearSession {
-}
-
-/**
- * Request: change language and/or label of the device
- * @start
- * @next Success
- * @next Failure
- */
-message ApplySettings {
- optional string language = 1;
- optional string label = 2;
- optional bool use_passphrase = 3;
- optional bytes homescreen = 4;
- optional PassphraseSourceType passphrase_source = 5;
- optional uint32 auto_lock_delay_ms = 6;
- optional uint32 display_rotation = 7; // in degrees from North
- /**
- * Structure representing passphrase source
- */
- enum PassphraseSourceType {
- ASK = 0;
- DEVICE = 1;
- HOST = 2;
- }
-}
-
-/**
- * Request: set flags of the device
- * @start
- * @next Success
- * @next Failure
- */
-message ApplyFlags {
- optional uint32 flags = 1; // bitmask, can only set bits, not unset
-}
-
-/**
- * Request: Starts workflow for setting/changing/removing the PIN
- * @start
- * @next Success
- * @next Failure
- */
-message ChangePin {
- optional bool remove = 1; // is PIN removal requested?
-}
-
-/**
- * Request: Test if the device is alive, device sends back the message in Success response
- * @start
- * @next Success
- */
-message Ping {
- optional string message = 1; // message to send back in Success message
- optional bool button_protection = 2; // ask for button press
- optional bool pin_protection = 3; // ask for PIN if set in device
- optional bool passphrase_protection = 4; // ask for passphrase if set in device
-}
-
-/**
- * Request: Abort last operation that required user interaction
- * @start
- * @next Failure
- */
-message Cancel {
-}
-
-/**
- * Request: Request a sample of random data generated by hardware RNG. May be used for testing.
- * @start
- * @next Entropy
- * @next Failure
- */
-message GetEntropy {
- required uint32 size = 1; // size of requested entropy
-}
-
-/**
- * Response: Reply with random data generated by internal RNG
- * @end
- */
-message Entropy {
- required bytes entropy = 1; // chunk of random generated bytes
-}
-
-/**
- * Request: Request device to wipe all sensitive data and settings
- * @start
- * @next Success
- * @next Failure
- */
-message WipeDevice {
-}
-
-/**
- * Request: Load seed and related internal settings from the computer
- * @start
- * @next Success
- * @next Failure
- */
-message LoadDevice {
- optional string mnemonic = 1; // seed encoded as BIP-39 mnemonic (12, 18 or 24 words)
- optional hw.trezor.messages.common.HDNodeType node = 2; // BIP-32 node
- optional string pin = 3; // set PIN protection
- optional bool passphrase_protection = 4; // enable master node encryption using passphrase
- optional string language = 5 [default='english']; // device language
- optional string label = 6; // device label
- optional bool skip_checksum = 7; // do not test mnemonic for valid BIP-39 checksum
- optional uint32 u2f_counter = 8; // U2F counter
-}
-
-/**
- * Request: Ask device to do initialization involving user interaction
- * @start
- * @next EntropyRequest
- * @next Failure
- */
-message ResetDevice {
- optional bool display_random = 1; // display entropy generated by the device before asking for additional entropy
- optional uint32 strength = 2 [default=256]; // strength of seed in bits
- optional bool passphrase_protection = 3; // enable master node encryption using passphrase
- optional bool pin_protection = 4; // enable PIN protection
- optional string language = 5 [default='english']; // device language
- optional string label = 6; // device label
- optional uint32 u2f_counter = 7; // U2F counter
- optional bool skip_backup = 8; // postpone seed backup to BackupDevice workflow
- optional bool no_backup = 9; // indicate that no backup is going to be made
-}
-
-/**
- * Request: Perform backup of the device seed if not backed up using ResetDevice
- * @start
- * @next Success
- */
-message BackupDevice {
-}
-
-/**
- * Response: Ask for additional entropy from host computer
- * @next EntropyAck
- */
-message EntropyRequest {
-}
-
-/**
- * Request: Provide additional entropy for seed generation function
- * @next Success
- */
-message EntropyAck {
- optional bytes entropy = 1; // 256 bits (32 bytes) of random data
-}
-
-/**
- * Request: Start recovery workflow asking user for specific words of mnemonic
- * Used to recovery device safely even on untrusted computer.
- * @start
- * @next WordRequest
- */
-message RecoveryDevice {
- optional uint32 word_count = 1; // number of words in BIP-39 mnemonic
- optional bool passphrase_protection = 2; // enable master node encryption using passphrase
- optional bool pin_protection = 3; // enable PIN protection
- optional string language = 4 [default='english']; // device language
- optional string label = 5; // device label
- optional bool enforce_wordlist = 6; // enforce BIP-39 wordlist during the process
- // 7 reserved for unused recovery method
- optional RecoveryDeviceType type = 8; // supported recovery type
- optional uint32 u2f_counter = 9; // U2F counter
- optional bool dry_run = 10; // perform dry-run recovery workflow (for safe mnemonic validation)
- /**
- * Type of recovery procedure. These should be used as bitmask, e.g.,
- * `RecoveryDeviceType_ScrambledWords | RecoveryDeviceType_Matrix`
- * listing every method supported by the host computer.
- *
- * Note that ScrambledWords must be supported by every implementation
- * for backward compatibility; there is no way to not support it.
- */
- enum RecoveryDeviceType {
- // use powers of two when extending this field
- RecoveryDeviceType_ScrambledWords = 0; // words in scrambled order
- RecoveryDeviceType_Matrix = 1; // matrix recovery type
- }
-}
-
-/**
- * Response: Device is waiting for user to enter word of the mnemonic
- * Its position is shown only on device's internal display.
- * @next WordAck
- */
-message WordRequest {
- optional WordRequestType type = 1;
- /**
- * Type of Recovery Word request
- */
- enum WordRequestType {
- WordRequestType_Plain = 0;
- WordRequestType_Matrix9 = 1;
- WordRequestType_Matrix6 = 2;
- }
-}
-
-/**
- * Request: Computer replies with word from the mnemonic
- * @next WordRequest
- * @next Success
- * @next Failure
- */
-message WordAck {
- required string word = 1; // one word of mnemonic on asked position
-}
-
-/**
- * Request: Set U2F counter
- * @start
- * @next Success
- */
-message SetU2FCounter {
- optional uint32 u2f_counter = 1; // counter
-}
diff --git a/accounts/usbwallet/trezor/messages.pb.go b/accounts/usbwallet/trezor/messages.pb.go
deleted file mode 100644
index af0c957144..0000000000
--- a/accounts/usbwallet/trezor/messages.pb.go
+++ /dev/null
@@ -1,889 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: messages.proto
-
-package trezor
-
-import (
- fmt "fmt"
- math "math"
-
- proto "github.com/golang/protobuf/proto"
- descriptor "github.com/golang/protobuf/protoc-gen-go/descriptor"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
-
-// *
-// Mapping between TREZOR wire identifier (uint) and a protobuf message
-type MessageType int32
-
-const (
- // Management
- MessageType_MessageType_Initialize MessageType = 0
- MessageType_MessageType_Ping MessageType = 1
- MessageType_MessageType_Success MessageType = 2
- MessageType_MessageType_Failure MessageType = 3
- MessageType_MessageType_ChangePin MessageType = 4
- MessageType_MessageType_WipeDevice MessageType = 5
- MessageType_MessageType_GetEntropy MessageType = 9
- MessageType_MessageType_Entropy MessageType = 10
- MessageType_MessageType_LoadDevice MessageType = 13
- MessageType_MessageType_ResetDevice MessageType = 14
- MessageType_MessageType_Features MessageType = 17
- MessageType_MessageType_PinMatrixRequest MessageType = 18
- MessageType_MessageType_PinMatrixAck MessageType = 19
- MessageType_MessageType_Cancel MessageType = 20
- MessageType_MessageType_ClearSession MessageType = 24
- MessageType_MessageType_ApplySettings MessageType = 25
- MessageType_MessageType_ButtonRequest MessageType = 26
- MessageType_MessageType_ButtonAck MessageType = 27
- MessageType_MessageType_ApplyFlags MessageType = 28
- MessageType_MessageType_BackupDevice MessageType = 34
- MessageType_MessageType_EntropyRequest MessageType = 35
- MessageType_MessageType_EntropyAck MessageType = 36
- MessageType_MessageType_PassphraseRequest MessageType = 41
- MessageType_MessageType_PassphraseAck MessageType = 42
- MessageType_MessageType_PassphraseStateRequest MessageType = 77
- MessageType_MessageType_PassphraseStateAck MessageType = 78
- MessageType_MessageType_RecoveryDevice MessageType = 45
- MessageType_MessageType_WordRequest MessageType = 46
- MessageType_MessageType_WordAck MessageType = 47
- MessageType_MessageType_GetFeatures MessageType = 55
- MessageType_MessageType_SetU2FCounter MessageType = 63
- // Bootloader
- MessageType_MessageType_FirmwareErase MessageType = 6
- MessageType_MessageType_FirmwareUpload MessageType = 7
- MessageType_MessageType_FirmwareRequest MessageType = 8
- MessageType_MessageType_SelfTest MessageType = 32
- // Bitcoin
- MessageType_MessageType_GetPublicKey MessageType = 11
- MessageType_MessageType_PublicKey MessageType = 12
- MessageType_MessageType_SignTx MessageType = 15
- MessageType_MessageType_TxRequest MessageType = 21
- MessageType_MessageType_TxAck MessageType = 22
- MessageType_MessageType_GetAddress MessageType = 29
- MessageType_MessageType_Address MessageType = 30
- MessageType_MessageType_SignMessage MessageType = 38
- MessageType_MessageType_VerifyMessage MessageType = 39
- MessageType_MessageType_MessageSignature MessageType = 40
- // Crypto
- MessageType_MessageType_CipherKeyValue MessageType = 23
- MessageType_MessageType_CipheredKeyValue MessageType = 48
- MessageType_MessageType_SignIdentity MessageType = 53
- MessageType_MessageType_SignedIdentity MessageType = 54
- MessageType_MessageType_GetECDHSessionKey MessageType = 61
- MessageType_MessageType_ECDHSessionKey MessageType = 62
- MessageType_MessageType_CosiCommit MessageType = 71
- MessageType_MessageType_CosiCommitment MessageType = 72
- MessageType_MessageType_CosiSign MessageType = 73
- MessageType_MessageType_CosiSignature MessageType = 74
- // Debug
- MessageType_MessageType_DebugLinkDecision MessageType = 100
- MessageType_MessageType_DebugLinkGetState MessageType = 101
- MessageType_MessageType_DebugLinkState MessageType = 102
- MessageType_MessageType_DebugLinkStop MessageType = 103
- MessageType_MessageType_DebugLinkLog MessageType = 104
- MessageType_MessageType_DebugLinkMemoryRead MessageType = 110
- MessageType_MessageType_DebugLinkMemory MessageType = 111
- MessageType_MessageType_DebugLinkMemoryWrite MessageType = 112
- MessageType_MessageType_DebugLinkFlashErase MessageType = 113
- // Ethereum
- MessageType_MessageType_EthereumGetPublicKey MessageType = 450
- MessageType_MessageType_EthereumPublicKey MessageType = 451
- MessageType_MessageType_EthereumGetAddress MessageType = 56
- MessageType_MessageType_EthereumAddress MessageType = 57
- MessageType_MessageType_EthereumSignTx MessageType = 58
- MessageType_MessageType_EthereumTxRequest MessageType = 59
- MessageType_MessageType_EthereumTxAck MessageType = 60
- MessageType_MessageType_EthereumSignMessage MessageType = 64
- MessageType_MessageType_EthereumVerifyMessage MessageType = 65
- MessageType_MessageType_EthereumMessageSignature MessageType = 66
- // NEM
- MessageType_MessageType_NEMGetAddress MessageType = 67
- MessageType_MessageType_NEMAddress MessageType = 68
- MessageType_MessageType_NEMSignTx MessageType = 69
- MessageType_MessageType_NEMSignedTx MessageType = 70
- MessageType_MessageType_NEMDecryptMessage MessageType = 75
- MessageType_MessageType_NEMDecryptedMessage MessageType = 76
- // Lisk
- MessageType_MessageType_LiskGetAddress MessageType = 114
- MessageType_MessageType_LiskAddress MessageType = 115
- MessageType_MessageType_LiskSignTx MessageType = 116
- MessageType_MessageType_LiskSignedTx MessageType = 117
- MessageType_MessageType_LiskSignMessage MessageType = 118
- MessageType_MessageType_LiskMessageSignature MessageType = 119
- MessageType_MessageType_LiskVerifyMessage MessageType = 120
- MessageType_MessageType_LiskGetPublicKey MessageType = 121
- MessageType_MessageType_LiskPublicKey MessageType = 122
- // Tezos
- MessageType_MessageType_TezosGetAddress MessageType = 150
- MessageType_MessageType_TezosAddress MessageType = 151
- MessageType_MessageType_TezosSignTx MessageType = 152
- MessageType_MessageType_TezosSignedTx MessageType = 153
- MessageType_MessageType_TezosGetPublicKey MessageType = 154
- MessageType_MessageType_TezosPublicKey MessageType = 155
- // Stellar
- MessageType_MessageType_StellarSignTx MessageType = 202
- MessageType_MessageType_StellarTxOpRequest MessageType = 203
- MessageType_MessageType_StellarGetAddress MessageType = 207
- MessageType_MessageType_StellarAddress MessageType = 208
- MessageType_MessageType_StellarCreateAccountOp MessageType = 210
- MessageType_MessageType_StellarPaymentOp MessageType = 211
- MessageType_MessageType_StellarPathPaymentOp MessageType = 212
- MessageType_MessageType_StellarManageOfferOp MessageType = 213
- MessageType_MessageType_StellarCreatePassiveOfferOp MessageType = 214
- MessageType_MessageType_StellarSetOptionsOp MessageType = 215
- MessageType_MessageType_StellarChangeTrustOp MessageType = 216
- MessageType_MessageType_StellarAllowTrustOp MessageType = 217
- MessageType_MessageType_StellarAccountMergeOp MessageType = 218
- // omitted: StellarInflationOp is not a supported operation, would be 219
- MessageType_MessageType_StellarManageDataOp MessageType = 220
- MessageType_MessageType_StellarBumpSequenceOp MessageType = 221
- MessageType_MessageType_StellarSignedTx MessageType = 230
- // TRON
- MessageType_MessageType_TronGetAddress MessageType = 250
- MessageType_MessageType_TronAddress MessageType = 251
- MessageType_MessageType_TronSignTx MessageType = 252
- MessageType_MessageType_TronSignedTx MessageType = 253
- // Cardano
- // dropped Sign/VerifyMessage ids 300-302
- MessageType_MessageType_CardanoSignTx MessageType = 303
- MessageType_MessageType_CardanoTxRequest MessageType = 304
- MessageType_MessageType_CardanoGetPublicKey MessageType = 305
- MessageType_MessageType_CardanoPublicKey MessageType = 306
- MessageType_MessageType_CardanoGetAddress MessageType = 307
- MessageType_MessageType_CardanoAddress MessageType = 308
- MessageType_MessageType_CardanoTxAck MessageType = 309
- MessageType_MessageType_CardanoSignedTx MessageType = 310
- // Ontology
- MessageType_MessageType_OntologyGetAddress MessageType = 350
- MessageType_MessageType_OntologyAddress MessageType = 351
- MessageType_MessageType_OntologyGetPublicKey MessageType = 352
- MessageType_MessageType_OntologyPublicKey MessageType = 353
- MessageType_MessageType_OntologySignTransfer MessageType = 354
- MessageType_MessageType_OntologySignedTransfer MessageType = 355
- MessageType_MessageType_OntologySignWithdrawOng MessageType = 356
- MessageType_MessageType_OntologySignedWithdrawOng MessageType = 357
- MessageType_MessageType_OntologySignOntIdRegister MessageType = 358
- MessageType_MessageType_OntologySignedOntIdRegister MessageType = 359
- MessageType_MessageType_OntologySignOntIdAddAttributes MessageType = 360
- MessageType_MessageType_OntologySignedOntIdAddAttributes MessageType = 361
- // Ripple
- MessageType_MessageType_RippleGetAddress MessageType = 400
- MessageType_MessageType_RippleAddress MessageType = 401
- MessageType_MessageType_RippleSignTx MessageType = 402
- MessageType_MessageType_RippleSignedTx MessageType = 403
- // Monero
- MessageType_MessageType_MoneroTransactionInitRequest MessageType = 501
- MessageType_MessageType_MoneroTransactionInitAck MessageType = 502
- MessageType_MessageType_MoneroTransactionSetInputRequest MessageType = 503
- MessageType_MessageType_MoneroTransactionSetInputAck MessageType = 504
- MessageType_MessageType_MoneroTransactionInputsPermutationRequest MessageType = 505
- MessageType_MessageType_MoneroTransactionInputsPermutationAck MessageType = 506
- MessageType_MessageType_MoneroTransactionInputViniRequest MessageType = 507
- MessageType_MessageType_MoneroTransactionInputViniAck MessageType = 508
- MessageType_MessageType_MoneroTransactionAllInputsSetRequest MessageType = 509
- MessageType_MessageType_MoneroTransactionAllInputsSetAck MessageType = 510
- MessageType_MessageType_MoneroTransactionSetOutputRequest MessageType = 511
- MessageType_MessageType_MoneroTransactionSetOutputAck MessageType = 512
- MessageType_MessageType_MoneroTransactionAllOutSetRequest MessageType = 513
- MessageType_MessageType_MoneroTransactionAllOutSetAck MessageType = 514
- MessageType_MessageType_MoneroTransactionSignInputRequest MessageType = 515
- MessageType_MessageType_MoneroTransactionSignInputAck MessageType = 516
- MessageType_MessageType_MoneroTransactionFinalRequest MessageType = 517
- MessageType_MessageType_MoneroTransactionFinalAck MessageType = 518
- MessageType_MessageType_MoneroKeyImageExportInitRequest MessageType = 530
- MessageType_MessageType_MoneroKeyImageExportInitAck MessageType = 531
- MessageType_MessageType_MoneroKeyImageSyncStepRequest MessageType = 532
- MessageType_MessageType_MoneroKeyImageSyncStepAck MessageType = 533
- MessageType_MessageType_MoneroKeyImageSyncFinalRequest MessageType = 534
- MessageType_MessageType_MoneroKeyImageSyncFinalAck MessageType = 535
- MessageType_MessageType_MoneroGetAddress MessageType = 540
- MessageType_MessageType_MoneroAddress MessageType = 541
- MessageType_MessageType_MoneroGetWatchKey MessageType = 542
- MessageType_MessageType_MoneroWatchKey MessageType = 543
- MessageType_MessageType_DebugMoneroDiagRequest MessageType = 546
- MessageType_MessageType_DebugMoneroDiagAck MessageType = 547
- MessageType_MessageType_MoneroGetTxKeyRequest MessageType = 550
- MessageType_MessageType_MoneroGetTxKeyAck MessageType = 551
- MessageType_MessageType_MoneroLiveRefreshStartRequest MessageType = 552
- MessageType_MessageType_MoneroLiveRefreshStartAck MessageType = 553
- MessageType_MessageType_MoneroLiveRefreshStepRequest MessageType = 554
- MessageType_MessageType_MoneroLiveRefreshStepAck MessageType = 555
- MessageType_MessageType_MoneroLiveRefreshFinalRequest MessageType = 556
- MessageType_MessageType_MoneroLiveRefreshFinalAck MessageType = 557
- // EOS
- MessageType_MessageType_EosGetPublicKey MessageType = 600
- MessageType_MessageType_EosPublicKey MessageType = 601
- MessageType_MessageType_EosSignTx MessageType = 602
- MessageType_MessageType_EosTxActionRequest MessageType = 603
- MessageType_MessageType_EosTxActionAck MessageType = 604
- MessageType_MessageType_EosSignedTx MessageType = 605
- // Binance
- MessageType_MessageType_BinanceGetAddress MessageType = 700
- MessageType_MessageType_BinanceAddress MessageType = 701
- MessageType_MessageType_BinanceGetPublicKey MessageType = 702
- MessageType_MessageType_BinancePublicKey MessageType = 703
- MessageType_MessageType_BinanceSignTx MessageType = 704
- MessageType_MessageType_BinanceTxRequest MessageType = 705
- MessageType_MessageType_BinanceTransferMsg MessageType = 706
- MessageType_MessageType_BinanceOrderMsg MessageType = 707
- MessageType_MessageType_BinanceCancelMsg MessageType = 708
- MessageType_MessageType_BinanceSignedTx MessageType = 709
-)
-
-var MessageType_name = map[int32]string{
- 0: "MessageType_Initialize",
- 1: "MessageType_Ping",
- 2: "MessageType_Success",
- 3: "MessageType_Failure",
- 4: "MessageType_ChangePin",
- 5: "MessageType_WipeDevice",
- 9: "MessageType_GetEntropy",
- 10: "MessageType_Entropy",
- 13: "MessageType_LoadDevice",
- 14: "MessageType_ResetDevice",
- 17: "MessageType_Features",
- 18: "MessageType_PinMatrixRequest",
- 19: "MessageType_PinMatrixAck",
- 20: "MessageType_Cancel",
- 24: "MessageType_ClearSession",
- 25: "MessageType_ApplySettings",
- 26: "MessageType_ButtonRequest",
- 27: "MessageType_ButtonAck",
- 28: "MessageType_ApplyFlags",
- 34: "MessageType_BackupDevice",
- 35: "MessageType_EntropyRequest",
- 36: "MessageType_EntropyAck",
- 41: "MessageType_PassphraseRequest",
- 42: "MessageType_PassphraseAck",
- 77: "MessageType_PassphraseStateRequest",
- 78: "MessageType_PassphraseStateAck",
- 45: "MessageType_RecoveryDevice",
- 46: "MessageType_WordRequest",
- 47: "MessageType_WordAck",
- 55: "MessageType_GetFeatures",
- 63: "MessageType_SetU2FCounter",
- 6: "MessageType_FirmwareErase",
- 7: "MessageType_FirmwareUpload",
- 8: "MessageType_FirmwareRequest",
- 32: "MessageType_SelfTest",
- 11: "MessageType_GetPublicKey",
- 12: "MessageType_PublicKey",
- 15: "MessageType_SignTx",
- 21: "MessageType_TxRequest",
- 22: "MessageType_TxAck",
- 29: "MessageType_GetAddress",
- 30: "MessageType_Address",
- 38: "MessageType_SignMessage",
- 39: "MessageType_VerifyMessage",
- 40: "MessageType_MessageSignature",
- 23: "MessageType_CipherKeyValue",
- 48: "MessageType_CipheredKeyValue",
- 53: "MessageType_SignIdentity",
- 54: "MessageType_SignedIdentity",
- 61: "MessageType_GetECDHSessionKey",
- 62: "MessageType_ECDHSessionKey",
- 71: "MessageType_CosiCommit",
- 72: "MessageType_CosiCommitment",
- 73: "MessageType_CosiSign",
- 74: "MessageType_CosiSignature",
- 100: "MessageType_DebugLinkDecision",
- 101: "MessageType_DebugLinkGetState",
- 102: "MessageType_DebugLinkState",
- 103: "MessageType_DebugLinkStop",
- 104: "MessageType_DebugLinkLog",
- 110: "MessageType_DebugLinkMemoryRead",
- 111: "MessageType_DebugLinkMemory",
- 112: "MessageType_DebugLinkMemoryWrite",
- 113: "MessageType_DebugLinkFlashErase",
- 450: "MessageType_EthereumGetPublicKey",
- 451: "MessageType_EthereumPublicKey",
- 56: "MessageType_EthereumGetAddress",
- 57: "MessageType_EthereumAddress",
- 58: "MessageType_EthereumSignTx",
- 59: "MessageType_EthereumTxRequest",
- 60: "MessageType_EthereumTxAck",
- 64: "MessageType_EthereumSignMessage",
- 65: "MessageType_EthereumVerifyMessage",
- 66: "MessageType_EthereumMessageSignature",
- 67: "MessageType_NEMGetAddress",
- 68: "MessageType_NEMAddress",
- 69: "MessageType_NEMSignTx",
- 70: "MessageType_NEMSignedTx",
- 75: "MessageType_NEMDecryptMessage",
- 76: "MessageType_NEMDecryptedMessage",
- 114: "MessageType_LiskGetAddress",
- 115: "MessageType_LiskAddress",
- 116: "MessageType_LiskSignTx",
- 117: "MessageType_LiskSignedTx",
- 118: "MessageType_LiskSignMessage",
- 119: "MessageType_LiskMessageSignature",
- 120: "MessageType_LiskVerifyMessage",
- 121: "MessageType_LiskGetPublicKey",
- 122: "MessageType_LiskPublicKey",
- 150: "MessageType_TezosGetAddress",
- 151: "MessageType_TezosAddress",
- 152: "MessageType_TezosSignTx",
- 153: "MessageType_TezosSignedTx",
- 154: "MessageType_TezosGetPublicKey",
- 155: "MessageType_TezosPublicKey",
- 202: "MessageType_StellarSignTx",
- 203: "MessageType_StellarTxOpRequest",
- 207: "MessageType_StellarGetAddress",
- 208: "MessageType_StellarAddress",
- 210: "MessageType_StellarCreateAccountOp",
- 211: "MessageType_StellarPaymentOp",
- 212: "MessageType_StellarPathPaymentOp",
- 213: "MessageType_StellarManageOfferOp",
- 214: "MessageType_StellarCreatePassiveOfferOp",
- 215: "MessageType_StellarSetOptionsOp",
- 216: "MessageType_StellarChangeTrustOp",
- 217: "MessageType_StellarAllowTrustOp",
- 218: "MessageType_StellarAccountMergeOp",
- 220: "MessageType_StellarManageDataOp",
- 221: "MessageType_StellarBumpSequenceOp",
- 230: "MessageType_StellarSignedTx",
- 250: "MessageType_TronGetAddress",
- 251: "MessageType_TronAddress",
- 252: "MessageType_TronSignTx",
- 253: "MessageType_TronSignedTx",
- 303: "MessageType_CardanoSignTx",
- 304: "MessageType_CardanoTxRequest",
- 305: "MessageType_CardanoGetPublicKey",
- 306: "MessageType_CardanoPublicKey",
- 307: "MessageType_CardanoGetAddress",
- 308: "MessageType_CardanoAddress",
- 309: "MessageType_CardanoTxAck",
- 310: "MessageType_CardanoSignedTx",
- 350: "MessageType_OntologyGetAddress",
- 351: "MessageType_OntologyAddress",
- 352: "MessageType_OntologyGetPublicKey",
- 353: "MessageType_OntologyPublicKey",
- 354: "MessageType_OntologySignTransfer",
- 355: "MessageType_OntologySignedTransfer",
- 356: "MessageType_OntologySignWithdrawOng",
- 357: "MessageType_OntologySignedWithdrawOng",
- 358: "MessageType_OntologySignOntIdRegister",
- 359: "MessageType_OntologySignedOntIdRegister",
- 360: "MessageType_OntologySignOntIdAddAttributes",
- 361: "MessageType_OntologySignedOntIdAddAttributes",
- 400: "MessageType_RippleGetAddress",
- 401: "MessageType_RippleAddress",
- 402: "MessageType_RippleSignTx",
- 403: "MessageType_RippleSignedTx",
- 501: "MessageType_MoneroTransactionInitRequest",
- 502: "MessageType_MoneroTransactionInitAck",
- 503: "MessageType_MoneroTransactionSetInputRequest",
- 504: "MessageType_MoneroTransactionSetInputAck",
- 505: "MessageType_MoneroTransactionInputsPermutationRequest",
- 506: "MessageType_MoneroTransactionInputsPermutationAck",
- 507: "MessageType_MoneroTransactionInputViniRequest",
- 508: "MessageType_MoneroTransactionInputViniAck",
- 509: "MessageType_MoneroTransactionAllInputsSetRequest",
- 510: "MessageType_MoneroTransactionAllInputsSetAck",
- 511: "MessageType_MoneroTransactionSetOutputRequest",
- 512: "MessageType_MoneroTransactionSetOutputAck",
- 513: "MessageType_MoneroTransactionAllOutSetRequest",
- 514: "MessageType_MoneroTransactionAllOutSetAck",
- 515: "MessageType_MoneroTransactionSignInputRequest",
- 516: "MessageType_MoneroTransactionSignInputAck",
- 517: "MessageType_MoneroTransactionFinalRequest",
- 518: "MessageType_MoneroTransactionFinalAck",
- 530: "MessageType_MoneroKeyImageExportInitRequest",
- 531: "MessageType_MoneroKeyImageExportInitAck",
- 532: "MessageType_MoneroKeyImageSyncStepRequest",
- 533: "MessageType_MoneroKeyImageSyncStepAck",
- 534: "MessageType_MoneroKeyImageSyncFinalRequest",
- 535: "MessageType_MoneroKeyImageSyncFinalAck",
- 540: "MessageType_MoneroGetAddress",
- 541: "MessageType_MoneroAddress",
- 542: "MessageType_MoneroGetWatchKey",
- 543: "MessageType_MoneroWatchKey",
- 546: "MessageType_DebugMoneroDiagRequest",
- 547: "MessageType_DebugMoneroDiagAck",
- 550: "MessageType_MoneroGetTxKeyRequest",
- 551: "MessageType_MoneroGetTxKeyAck",
- 552: "MessageType_MoneroLiveRefreshStartRequest",
- 553: "MessageType_MoneroLiveRefreshStartAck",
- 554: "MessageType_MoneroLiveRefreshStepRequest",
- 555: "MessageType_MoneroLiveRefreshStepAck",
- 556: "MessageType_MoneroLiveRefreshFinalRequest",
- 557: "MessageType_MoneroLiveRefreshFinalAck",
- 600: "MessageType_EosGetPublicKey",
- 601: "MessageType_EosPublicKey",
- 602: "MessageType_EosSignTx",
- 603: "MessageType_EosTxActionRequest",
- 604: "MessageType_EosTxActionAck",
- 605: "MessageType_EosSignedTx",
- 700: "MessageType_BinanceGetAddress",
- 701: "MessageType_BinanceAddress",
- 702: "MessageType_BinanceGetPublicKey",
- 703: "MessageType_BinancePublicKey",
- 704: "MessageType_BinanceSignTx",
- 705: "MessageType_BinanceTxRequest",
- 706: "MessageType_BinanceTransferMsg",
- 707: "MessageType_BinanceOrderMsg",
- 708: "MessageType_BinanceCancelMsg",
- 709: "MessageType_BinanceSignedTx",
-}
-
-var MessageType_value = map[string]int32{
- "MessageType_Initialize": 0,
- "MessageType_Ping": 1,
- "MessageType_Success": 2,
- "MessageType_Failure": 3,
- "MessageType_ChangePin": 4,
- "MessageType_WipeDevice": 5,
- "MessageType_GetEntropy": 9,
- "MessageType_Entropy": 10,
- "MessageType_LoadDevice": 13,
- "MessageType_ResetDevice": 14,
- "MessageType_Features": 17,
- "MessageType_PinMatrixRequest": 18,
- "MessageType_PinMatrixAck": 19,
- "MessageType_Cancel": 20,
- "MessageType_ClearSession": 24,
- "MessageType_ApplySettings": 25,
- "MessageType_ButtonRequest": 26,
- "MessageType_ButtonAck": 27,
- "MessageType_ApplyFlags": 28,
- "MessageType_BackupDevice": 34,
- "MessageType_EntropyRequest": 35,
- "MessageType_EntropyAck": 36,
- "MessageType_PassphraseRequest": 41,
- "MessageType_PassphraseAck": 42,
- "MessageType_PassphraseStateRequest": 77,
- "MessageType_PassphraseStateAck": 78,
- "MessageType_RecoveryDevice": 45,
- "MessageType_WordRequest": 46,
- "MessageType_WordAck": 47,
- "MessageType_GetFeatures": 55,
- "MessageType_SetU2FCounter": 63,
- "MessageType_FirmwareErase": 6,
- "MessageType_FirmwareUpload": 7,
- "MessageType_FirmwareRequest": 8,
- "MessageType_SelfTest": 32,
- "MessageType_GetPublicKey": 11,
- "MessageType_PublicKey": 12,
- "MessageType_SignTx": 15,
- "MessageType_TxRequest": 21,
- "MessageType_TxAck": 22,
- "MessageType_GetAddress": 29,
- "MessageType_Address": 30,
- "MessageType_SignMessage": 38,
- "MessageType_VerifyMessage": 39,
- "MessageType_MessageSignature": 40,
- "MessageType_CipherKeyValue": 23,
- "MessageType_CipheredKeyValue": 48,
- "MessageType_SignIdentity": 53,
- "MessageType_SignedIdentity": 54,
- "MessageType_GetECDHSessionKey": 61,
- "MessageType_ECDHSessionKey": 62,
- "MessageType_CosiCommit": 71,
- "MessageType_CosiCommitment": 72,
- "MessageType_CosiSign": 73,
- "MessageType_CosiSignature": 74,
- "MessageType_DebugLinkDecision": 100,
- "MessageType_DebugLinkGetState": 101,
- "MessageType_DebugLinkState": 102,
- "MessageType_DebugLinkStop": 103,
- "MessageType_DebugLinkLog": 104,
- "MessageType_DebugLinkMemoryRead": 110,
- "MessageType_DebugLinkMemory": 111,
- "MessageType_DebugLinkMemoryWrite": 112,
- "MessageType_DebugLinkFlashErase": 113,
- "MessageType_EthereumGetPublicKey": 450,
- "MessageType_EthereumPublicKey": 451,
- "MessageType_EthereumGetAddress": 56,
- "MessageType_EthereumAddress": 57,
- "MessageType_EthereumSignTx": 58,
- "MessageType_EthereumTxRequest": 59,
- "MessageType_EthereumTxAck": 60,
- "MessageType_EthereumSignMessage": 64,
- "MessageType_EthereumVerifyMessage": 65,
- "MessageType_EthereumMessageSignature": 66,
- "MessageType_NEMGetAddress": 67,
- "MessageType_NEMAddress": 68,
- "MessageType_NEMSignTx": 69,
- "MessageType_NEMSignedTx": 70,
- "MessageType_NEMDecryptMessage": 75,
- "MessageType_NEMDecryptedMessage": 76,
- "MessageType_LiskGetAddress": 114,
- "MessageType_LiskAddress": 115,
- "MessageType_LiskSignTx": 116,
- "MessageType_LiskSignedTx": 117,
- "MessageType_LiskSignMessage": 118,
- "MessageType_LiskMessageSignature": 119,
- "MessageType_LiskVerifyMessage": 120,
- "MessageType_LiskGetPublicKey": 121,
- "MessageType_LiskPublicKey": 122,
- "MessageType_TezosGetAddress": 150,
- "MessageType_TezosAddress": 151,
- "MessageType_TezosSignTx": 152,
- "MessageType_TezosSignedTx": 153,
- "MessageType_TezosGetPublicKey": 154,
- "MessageType_TezosPublicKey": 155,
- "MessageType_StellarSignTx": 202,
- "MessageType_StellarTxOpRequest": 203,
- "MessageType_StellarGetAddress": 207,
- "MessageType_StellarAddress": 208,
- "MessageType_StellarCreateAccountOp": 210,
- "MessageType_StellarPaymentOp": 211,
- "MessageType_StellarPathPaymentOp": 212,
- "MessageType_StellarManageOfferOp": 213,
- "MessageType_StellarCreatePassiveOfferOp": 214,
- "MessageType_StellarSetOptionsOp": 215,
- "MessageType_StellarChangeTrustOp": 216,
- "MessageType_StellarAllowTrustOp": 217,
- "MessageType_StellarAccountMergeOp": 218,
- "MessageType_StellarManageDataOp": 220,
- "MessageType_StellarBumpSequenceOp": 221,
- "MessageType_StellarSignedTx": 230,
- "MessageType_TronGetAddress": 250,
- "MessageType_TronAddress": 251,
- "MessageType_TronSignTx": 252,
- "MessageType_TronSignedTx": 253,
- "MessageType_CardanoSignTx": 303,
- "MessageType_CardanoTxRequest": 304,
- "MessageType_CardanoGetPublicKey": 305,
- "MessageType_CardanoPublicKey": 306,
- "MessageType_CardanoGetAddress": 307,
- "MessageType_CardanoAddress": 308,
- "MessageType_CardanoTxAck": 309,
- "MessageType_CardanoSignedTx": 310,
- "MessageType_OntologyGetAddress": 350,
- "MessageType_OntologyAddress": 351,
- "MessageType_OntologyGetPublicKey": 352,
- "MessageType_OntologyPublicKey": 353,
- "MessageType_OntologySignTransfer": 354,
- "MessageType_OntologySignedTransfer": 355,
- "MessageType_OntologySignWithdrawOng": 356,
- "MessageType_OntologySignedWithdrawOng": 357,
- "MessageType_OntologySignOntIdRegister": 358,
- "MessageType_OntologySignedOntIdRegister": 359,
- "MessageType_OntologySignOntIdAddAttributes": 360,
- "MessageType_OntologySignedOntIdAddAttributes": 361,
- "MessageType_RippleGetAddress": 400,
- "MessageType_RippleAddress": 401,
- "MessageType_RippleSignTx": 402,
- "MessageType_RippleSignedTx": 403,
- "MessageType_MoneroTransactionInitRequest": 501,
- "MessageType_MoneroTransactionInitAck": 502,
- "MessageType_MoneroTransactionSetInputRequest": 503,
- "MessageType_MoneroTransactionSetInputAck": 504,
- "MessageType_MoneroTransactionInputsPermutationRequest": 505,
- "MessageType_MoneroTransactionInputsPermutationAck": 506,
- "MessageType_MoneroTransactionInputViniRequest": 507,
- "MessageType_MoneroTransactionInputViniAck": 508,
- "MessageType_MoneroTransactionAllInputsSetRequest": 509,
- "MessageType_MoneroTransactionAllInputsSetAck": 510,
- "MessageType_MoneroTransactionSetOutputRequest": 511,
- "MessageType_MoneroTransactionSetOutputAck": 512,
- "MessageType_MoneroTransactionAllOutSetRequest": 513,
- "MessageType_MoneroTransactionAllOutSetAck": 514,
- "MessageType_MoneroTransactionSignInputRequest": 515,
- "MessageType_MoneroTransactionSignInputAck": 516,
- "MessageType_MoneroTransactionFinalRequest": 517,
- "MessageType_MoneroTransactionFinalAck": 518,
- "MessageType_MoneroKeyImageExportInitRequest": 530,
- "MessageType_MoneroKeyImageExportInitAck": 531,
- "MessageType_MoneroKeyImageSyncStepRequest": 532,
- "MessageType_MoneroKeyImageSyncStepAck": 533,
- "MessageType_MoneroKeyImageSyncFinalRequest": 534,
- "MessageType_MoneroKeyImageSyncFinalAck": 535,
- "MessageType_MoneroGetAddress": 540,
- "MessageType_MoneroAddress": 541,
- "MessageType_MoneroGetWatchKey": 542,
- "MessageType_MoneroWatchKey": 543,
- "MessageType_DebugMoneroDiagRequest": 546,
- "MessageType_DebugMoneroDiagAck": 547,
- "MessageType_MoneroGetTxKeyRequest": 550,
- "MessageType_MoneroGetTxKeyAck": 551,
- "MessageType_MoneroLiveRefreshStartRequest": 552,
- "MessageType_MoneroLiveRefreshStartAck": 553,
- "MessageType_MoneroLiveRefreshStepRequest": 554,
- "MessageType_MoneroLiveRefreshStepAck": 555,
- "MessageType_MoneroLiveRefreshFinalRequest": 556,
- "MessageType_MoneroLiveRefreshFinalAck": 557,
- "MessageType_EosGetPublicKey": 600,
- "MessageType_EosPublicKey": 601,
- "MessageType_EosSignTx": 602,
- "MessageType_EosTxActionRequest": 603,
- "MessageType_EosTxActionAck": 604,
- "MessageType_EosSignedTx": 605,
- "MessageType_BinanceGetAddress": 700,
- "MessageType_BinanceAddress": 701,
- "MessageType_BinanceGetPublicKey": 702,
- "MessageType_BinancePublicKey": 703,
- "MessageType_BinanceSignTx": 704,
- "MessageType_BinanceTxRequest": 705,
- "MessageType_BinanceTransferMsg": 706,
- "MessageType_BinanceOrderMsg": 707,
- "MessageType_BinanceCancelMsg": 708,
- "MessageType_BinanceSignedTx": 709,
-}
-
-func (x MessageType) Enum() *MessageType {
- p := new(MessageType)
- *p = x
- return p
-}
-
-func (x MessageType) String() string {
- return proto.EnumName(MessageType_name, int32(x))
-}
-
-func (x *MessageType) UnmarshalJSON(data []byte) error {
- value, err := proto.UnmarshalJSONEnum(MessageType_value, data, "MessageType")
- if err != nil {
- return err
- }
- *x = MessageType(value)
- return nil
-}
-
-func (MessageType) EnumDescriptor() ([]byte, []int) {
- return fileDescriptor_4dc296cbfe5ffcd5, []int{0}
-}
-
-var E_WireIn = &proto.ExtensionDesc{
- ExtendedType: (*descriptor.EnumValueOptions)(nil),
- ExtensionType: (*bool)(nil),
- Field: 50002,
- Name: "hw.trezor.messages.wire_in",
- Tag: "varint,50002,opt,name=wire_in",
- Filename: "messages.proto",
-}
-
-var E_WireOut = &proto.ExtensionDesc{
- ExtendedType: (*descriptor.EnumValueOptions)(nil),
- ExtensionType: (*bool)(nil),
- Field: 50003,
- Name: "hw.trezor.messages.wire_out",
- Tag: "varint,50003,opt,name=wire_out",
- Filename: "messages.proto",
-}
-
-var E_WireDebugIn = &proto.ExtensionDesc{
- ExtendedType: (*descriptor.EnumValueOptions)(nil),
- ExtensionType: (*bool)(nil),
- Field: 50004,
- Name: "hw.trezor.messages.wire_debug_in",
- Tag: "varint,50004,opt,name=wire_debug_in",
- Filename: "messages.proto",
-}
-
-var E_WireDebugOut = &proto.ExtensionDesc{
- ExtendedType: (*descriptor.EnumValueOptions)(nil),
- ExtensionType: (*bool)(nil),
- Field: 50005,
- Name: "hw.trezor.messages.wire_debug_out",
- Tag: "varint,50005,opt,name=wire_debug_out",
- Filename: "messages.proto",
-}
-
-var E_WireTiny = &proto.ExtensionDesc{
- ExtendedType: (*descriptor.EnumValueOptions)(nil),
- ExtensionType: (*bool)(nil),
- Field: 50006,
- Name: "hw.trezor.messages.wire_tiny",
- Tag: "varint,50006,opt,name=wire_tiny",
- Filename: "messages.proto",
-}
-
-var E_WireBootloader = &proto.ExtensionDesc{
- ExtendedType: (*descriptor.EnumValueOptions)(nil),
- ExtensionType: (*bool)(nil),
- Field: 50007,
- Name: "hw.trezor.messages.wire_bootloader",
- Tag: "varint,50007,opt,name=wire_bootloader",
- Filename: "messages.proto",
-}
-
-var E_WireNoFsm = &proto.ExtensionDesc{
- ExtendedType: (*descriptor.EnumValueOptions)(nil),
- ExtensionType: (*bool)(nil),
- Field: 50008,
- Name: "hw.trezor.messages.wire_no_fsm",
- Tag: "varint,50008,opt,name=wire_no_fsm",
- Filename: "messages.proto",
-}
-
-func init() {
- proto.RegisterEnum("hw.trezor.messages.MessageType", MessageType_name, MessageType_value)
- proto.RegisterExtension(E_WireIn)
- proto.RegisterExtension(E_WireOut)
- proto.RegisterExtension(E_WireDebugIn)
- proto.RegisterExtension(E_WireDebugOut)
- proto.RegisterExtension(E_WireTiny)
- proto.RegisterExtension(E_WireBootloader)
- proto.RegisterExtension(E_WireNoFsm)
-}
-
-func init() { proto.RegisterFile("messages.proto", fileDescriptor_4dc296cbfe5ffcd5) }
-
-var fileDescriptor_4dc296cbfe5ffcd5 = []byte{
- // 2430 bytes of a gzipped FileDescriptorProto
- 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x9a, 0xd9, 0x73, 0x1c, 0xc5,
- 0x1d, 0xc7, 0xb3, 0xab, 0x11, 0x88, 0xf6, 0x41, 0x23, 0xb0, 0x2d, 0xaf, 0x2f, 0xf9, 0xc0, 0x96,
- 0x2f, 0xd9, 0x10, 0x0c, 0x44, 0x38, 0x60, 0x69, 0xb5, 0x12, 0x8a, 0xb5, 0x5a, 0x97, 0x76, 0xb1,
- 0x1f, 0x5d, 0xa3, 0x9d, 0xd6, 0x6e, 0x97, 0x67, 0x67, 0x86, 0x9e, 0x1e, 0x49, 0xeb, 0xa7, 0x9c,
- 0x3c, 0x13, 0x48, 0xc0, 0xb9, 0xa9, 0xa4, 0x2a, 0x21, 0x57, 0x85, 0x1c, 0x4e, 0x25, 0x55, 0x39,
- 0x08, 0x24, 0x2f, 0xc9, 0x43, 0x52, 0x9c, 0x86, 0x40, 0xee, 0x90, 0xe4, 0x0f, 0xc8, 0xc5, 0x91,
- 0xa4, 0x7a, 0xa6, 0xbb, 0xe7, 0xd8, 0xdf, 0xae, 0x36, 0x6f, 0x58, 0xf3, 0xf9, 0x7d, 0x7f, 0x47,
- 0xff, 0xfa, 0x37, 0xdd, 0xb3, 0xa0, 0xcd, 0x2d, 0xe2, 0xfb, 0x66, 0x83, 0xf8, 0xe3, 0x1e, 0x73,
- 0xb9, 0x3b, 0x3c, 0xdc, 0x5c, 0x1d, 0xe7, 0x8c, 0x5c, 0x76, 0xd9, 0xb8, 0x7a, 0x52, 0x18, 0x6d,
- 0xb8, 0x6e, 0xc3, 0x26, 0x27, 0x42, 0x62, 0x29, 0x58, 0x3e, 0x61, 0x11, 0xbf, 0xce, 0xa8, 0xc7,
- 0x5d, 0x16, 0x59, 0x1d, 0xf9, 0xfe, 0x7d, 0x68, 0x43, 0x39, 0xc2, 0x6b, 0x6d, 0x8f, 0x0c, 0x1f,
- 0x40, 0x5b, 0x13, 0xff, 0xbc, 0x38, 0xe7, 0x50, 0x4e, 0x4d, 0x9b, 0x5e, 0x26, 0xf8, 0x5d, 0x85,
- 0xa1, 0x87, 0xaf, 0x8e, 0xe4, 0x9e, 0xba, 0x3a, 0x92, 0x1b, 0x2e, 0x20, 0x9c, 0xa4, 0xce, 0x51,
- 0xa7, 0x81, 0x73, 0x05, 0x43, 0x3c, 0x1f, 0xde, 0x85, 0x6e, 0x4e, 0x3e, 0xab, 0x06, 0xf5, 0x3a,
- 0xf1, 0x7d, 0x9c, 0x2f, 0x18, 0x57, 0x80, 0xc7, 0x33, 0x26, 0xb5, 0x03, 0x46, 0xf0, 0x80, 0x7c,
- 0xbc, 0x07, 0x6d, 0x49, 0x3e, 0x2e, 0x36, 0x4d, 0xa7, 0x41, 0xce, 0x51, 0x07, 0x1b, 0x52, 0x7e,
- 0x34, 0x1d, 0xe0, 0x05, 0xea, 0x91, 0x69, 0xb2, 0x42, 0xeb, 0x04, 0x0f, 0xc2, 0xc4, 0x2c, 0xe1,
- 0x25, 0x87, 0x33, 0xd7, 0x6b, 0xe3, 0x1b, 0xe0, 0x10, 0xd5, 0x63, 0x24, 0x63, 0xc8, 0x08, 0xcc,
- 0xbb, 0xa6, 0x25, 0x5d, 0x6c, 0x92, 0x02, 0x7b, 0xd1, 0xb6, 0x24, 0xb1, 0x48, 0x7c, 0xc2, 0x25,
- 0xb2, 0x59, 0x22, 0xbb, 0xd1, 0x2d, 0xa9, 0x3c, 0x89, 0xc9, 0x03, 0x46, 0x7c, 0x7c, 0x93, 0x74,
- 0x72, 0x10, 0xed, 0xcc, 0x94, 0xb0, 0x6c, 0x72, 0x46, 0xd7, 0x16, 0xc9, 0x83, 0x01, 0xf1, 0x39,
- 0x1e, 0x96, 0xdc, 0x11, 0x34, 0x02, 0x72, 0x93, 0xf5, 0x4b, 0xf8, 0xe6, 0xc2, 0x46, 0xb5, 0x24,
- 0x4f, 0x47, 0x81, 0x0f, 0xa7, 0x8a, 0x67, 0x3a, 0x75, 0x62, 0xe3, 0x5b, 0x12, 0x0b, 0xb7, 0x2f,
- 0xad, 0x56, 0xb4, 0x89, 0xc9, 0xaa, 0xc4, 0xf7, 0xa9, 0xeb, 0xe0, 0x11, 0x19, 0xf9, 0x7e, 0xb4,
- 0x3d, 0xc9, 0x4c, 0x7a, 0x9e, 0xdd, 0xae, 0x12, 0xce, 0xa9, 0xd3, 0xf0, 0xf1, 0x76, 0x18, 0x9a,
- 0x0a, 0x38, 0x77, 0x1d, 0x15, 0x7b, 0x41, 0xc6, 0x7e, 0x28, 0xbd, 0x98, 0x11, 0x24, 0x02, 0xdf,
- 0xd1, 0x11, 0xf8, 0xd6, 0x0e, 0x97, 0x33, 0xb6, 0xd9, 0xf0, 0xf1, 0x4e, 0xe9, 0x2f, 0x13, 0xf8,
- 0x94, 0x59, 0xbf, 0x14, 0x78, 0xb2, 0xe4, 0xfb, 0x24, 0x73, 0x00, 0x15, 0x80, 0x65, 0x55, 0x41,
- 0xed, 0x87, 0x57, 0x57, 0x52, 0x22, 0xaa, 0x03, 0x52, 0xe7, 0x10, 0xda, 0x95, 0x2a, 0xb9, 0xe9,
- 0xfb, 0x5e, 0x93, 0x99, 0x3e, 0x51, 0x52, 0x87, 0xa5, 0xd4, 0xd1, 0x74, 0x11, 0x62, 0x50, 0xa8,
- 0x1d, 0xc9, 0xe4, 0x78, 0x0c, 0xed, 0x83, 0xe1, 0x2a, 0x37, 0xb9, 0x96, 0x2e, 0x4b, 0xe9, 0x93,
- 0x68, 0x77, 0x0f, 0x5a, 0xe8, 0x2f, 0x64, 0xf4, 0x33, 0xd9, 0x2f, 0x92, 0xba, 0xbb, 0x42, 0x58,
- 0x5b, 0xd6, 0xe8, 0x38, 0xdc, 0xb9, 0x17, 0x5c, 0x66, 0x29, 0xd7, 0xe3, 0xf0, 0x0e, 0x15, 0x88,
- 0xf0, 0x77, 0x02, 0x56, 0x98, 0x25, 0x5c, 0xf7, 0xf6, 0x5d, 0x70, 0x73, 0x54, 0x09, 0x7f, 0xe0,
- 0xf6, 0x99, 0xa2, 0x1b, 0x38, 0x9c, 0x30, 0x7c, 0x9f, 0xae, 0x72, 0x0a, 0x9a, 0xa1, 0xac, 0xb5,
- 0x6a, 0x32, 0x52, 0x12, 0x49, 0xe2, 0xeb, 0xa2, 0x9e, 0xfd, 0x9e, 0x00, 0xc7, 0xd2, 0x89, 0x29,
- 0xf0, 0x01, 0xcf, 0x76, 0x4d, 0x0b, 0x5f, 0x9f, 0x20, 0x0f, 0xa3, 0x1d, 0x10, 0xa9, 0x12, 0x1c,
- 0x2a, 0x0c, 0x5d, 0x51, 0xe8, 0xbe, 0xf4, 0xf6, 0xac, 0x12, 0x7b, 0xb9, 0x26, 0x98, 0xd1, 0x84,
- 0x5c, 0xa6, 0xe7, 0x66, 0x09, 0x3f, 0x17, 0x2c, 0xd9, 0xb4, 0x7e, 0x96, 0xb4, 0xf1, 0x06, 0x99,
- 0x45, 0x66, 0x5e, 0xc5, 0xc0, 0x46, 0x59, 0xcd, 0x9d, 0xe9, 0x3d, 0x59, 0xa5, 0x0d, 0xa7, 0xb6,
- 0x86, 0x6f, 0x84, 0xcd, 0x6b, 0x7a, 0xfb, 0x6f, 0x91, 0xe6, 0x3b, 0xd0, 0x4d, 0x69, 0x40, 0x2c,
- 0xc5, 0xd6, 0xae, 0x93, 0x6e, 0xd2, 0xb2, 0x98, 0x98, 0xb6, 0xbb, 0xe0, 0x49, 0xa7, 0x1e, 0xef,
- 0x96, 0xea, 0x99, 0xb5, 0x14, 0xc1, 0xc9, 0x7f, 0xe3, 0x83, 0xf0, 0x5a, 0x9e, 0x27, 0x8c, 0x2e,
- 0xb7, 0x15, 0x74, 0x48, 0x42, 0x99, 0x61, 0x26, 0xff, 0x5b, 0xc8, 0x85, 0x9d, 0x81, 0xc7, 0xa4,
- 0xbf, 0x4c, 0x8f, 0x16, 0xa9, 0xd7, 0x24, 0xec, 0x2c, 0x69, 0x9f, 0x37, 0xed, 0x80, 0xe0, 0x6d,
- 0xb0, 0x5a, 0x44, 0x11, 0x4b, 0x73, 0x27, 0xa5, 0x5a, 0x66, 0x7d, 0x84, 0xbb, 0x39, 0x8b, 0x38,
- 0x9c, 0xf2, 0x36, 0x3e, 0x05, 0xcf, 0x04, 0xc1, 0x10, 0x4b, 0x53, 0x77, 0xea, 0x41, 0xb5, 0x2b,
- 0xfb, 0xca, 0x28, 0x4e, 0xdf, 0x2f, 0x07, 0xa3, 0x58, 0xcd, 0xf7, 0x76, 0x19, 0x31, 0x69, 0xea,
- 0x5e, 0x78, 0xc4, 0x14, 0x5d, 0x9f, 0x16, 0xdd, 0x56, 0x8b, 0x72, 0x3c, 0x0b, 0xeb, 0xc4, 0x44,
- 0x8b, 0x38, 0x1c, 0xdf, 0x2f, 0x75, 0x32, 0xef, 0x10, 0x41, 0x89, 0x04, 0xf0, 0x1c, 0xbc, 0x36,
- 0xea, 0x79, 0x54, 0xf3, 0xf7, 0x49, 0x91, 0x13, 0xe9, 0xdc, 0xa6, 0xc9, 0x52, 0xd0, 0x98, 0xa7,
- 0xce, 0xa5, 0x69, 0x52, 0xa7, 0xe1, 0xdc, 0xb7, 0x0a, 0x1b, 0x9f, 0x48, 0x0e, 0x92, 0xa3, 0x5d,
- 0x0c, 0x66, 0x09, 0x0f, 0x87, 0x0f, 0x26, 0x85, 0x21, 0x65, 0x90, 0x4d, 0x44, 0xc3, 0x11, 0xb9,
- 0x5c, 0x30, 0x9e, 0x04, 0x02, 0x4d, 0x50, 0xae, 0x87, 0x1b, 0x05, 0xe3, 0x09, 0x60, 0x39, 0x35,
- 0x34, 0xef, 0x36, 0x70, 0x53, 0x0a, 0x1d, 0x46, 0x7b, 0x40, 0xa6, 0x4c, 0x5a, 0x2e, 0x6b, 0x2f,
- 0x12, 0xd3, 0xc2, 0x8e, 0x94, 0xbb, 0x35, 0x3d, 0x0c, 0x32, 0x28, 0x76, 0xa5, 0xe2, 0x11, 0x34,
- 0xda, 0x03, 0xbb, 0xc0, 0x28, 0x27, 0xd8, 0x93, 0x92, 0xdd, 0xbc, 0xcf, 0xd8, 0xa6, 0xdf, 0x8c,
- 0x06, 0xd7, 0x83, 0x12, 0x3d, 0x9a, 0x96, 0x2d, 0x71, 0xd1, 0xc2, 0x41, 0x2b, 0x35, 0x43, 0x9e,
- 0x19, 0x90, 0xeb, 0x38, 0x96, 0xae, 0xb8, 0x82, 0x63, 0xf2, 0x59, 0x75, 0x3c, 0x1a, 0x4b, 0xbf,
- 0x16, 0x12, 0xb2, 0x6a, 0x6b, 0xdf, 0x2d, 0x35, 0x33, 0xe9, 0x2b, 0x52, 0x61, 0xef, 0x81, 0x77,
- 0xa4, 0xc2, 0xe4, 0x98, 0x9a, 0x80, 0xdf, 0x88, 0x8a, 0x8a, 0xc7, 0xd5, 0x3d, 0x52, 0x2e, 0xb3,
- 0xd0, 0x31, 0x28, 0xc6, 0xd6, 0x69, 0xa9, 0x96, 0x29, 0x63, 0xd2, 0xa7, 0x1a, 0x2c, 0x67, 0x24,
- 0x7a, 0x14, 0xed, 0x85, 0xd0, 0xf4, 0x14, 0x9a, 0x94, 0xf0, 0x38, 0x3a, 0x00, 0xc1, 0x1d, 0xd3,
- 0x68, 0x0a, 0x0e, 0x76, 0xa1, 0x54, 0x4e, 0xd4, 0xb1, 0x08, 0xcf, 0xd8, 0x85, 0x52, 0x59, 0x11,
- 0xd3, 0xf0, 0x91, 0x75, 0xa1, 0x54, 0x96, 0xd5, 0x2b, 0xc1, 0x6f, 0x4c, 0x09, 0x10, 0xab, 0xb6,
- 0x86, 0x67, 0xe0, 0x01, 0xb4, 0x50, 0x2a, 0x4f, 0x93, 0x3a, 0x6b, 0x7b, 0x5c, 0xe5, 0x78, 0x16,
- 0xae, 0x5d, 0x0c, 0x12, 0x4b, 0xa1, 0xf3, 0xf0, 0xd2, 0xce, 0x53, 0xff, 0x52, 0x22, 0x3f, 0x06,
- 0x07, 0x27, 0x28, 0x85, 0xf8, 0x5d, 0xce, 0xc3, 0xd4, 0xbf, 0x24, 0x33, 0xe4, 0xf0, 0xe9, 0x4c,
- 0x11, 0x61, 0x8a, 0x81, 0x54, 0xc9, 0x34, 0xa4, 0x62, 0x54, 0xd4, 0x2b, 0x52, 0x2a, 0xb3, 0x1f,
- 0x05, 0xd6, 0xb1, 0x80, 0xab, 0x70, 0xd5, 0x04, 0x9b, 0xee, 0x8c, 0x35, 0xf8, 0x8d, 0x22, 0x4b,
- 0x11, 0xef, 0xaf, 0x36, 0x3c, 0x50, 0x05, 0x17, 0x43, 0x97, 0xf5, 0xc9, 0x3d, 0x95, 0x48, 0x8d,
- 0x5c, 0x76, 0xfd, 0x44, 0x61, 0x1f, 0xcb, 0x69, 0xb1, 0x91, 0x0e, 0x4e, 0x41, 0x8f, 0xe7, 0xf4,
- 0x3b, 0x6c, 0x5b, 0x07, 0x24, 0x8b, 0x7b, 0x25, 0xa7, 0x5f, 0x16, 0xdb, 0x41, 0x26, 0x2c, 0xef,
- 0x27, 0x72, 0x7a, 0x34, 0xec, 0x82, 0xc2, 0x8a, 0xe3, 0xff, 0x64, 0x4e, 0x8f, 0x86, 0x42, 0x07,
- 0x19, 0x63, 0x9f, 0xca, 0xe9, 0xfe, 0x49, 0x9f, 0xe2, 0x38, 0xb1, 0x6d, 0x93, 0xc9, 0xe0, 0x7e,
- 0x9e, 0xd3, 0x0d, 0xb9, 0x1b, 0xa0, 0x6a, 0x6b, 0x15, 0x4f, 0xcd, 0x86, 0x5f, 0x74, 0x89, 0x50,
- 0xa2, 0x89, 0xd2, 0xfd, 0xb2, 0x4b, 0x84, 0x92, 0x54, 0xd8, 0xaf, 0x94, 0xe0, 0xf1, 0xf4, 0x91,
- 0x5a, 0x62, 0x45, 0x46, 0xc2, 0x23, 0x72, 0x5d, 0x1c, 0x38, 0x2b, 0x1e, 0x7e, 0x2e, 0xa7, 0xa7,
- 0xd8, 0x4e, 0x00, 0x3f, 0x67, 0xb6, 0xc5, 0x4b, 0xb7, 0xe2, 0xe1, 0xe7, 0x73, 0x7a, 0xea, 0x8c,
- 0x82, 0x20, 0x6f, 0xc6, 0xf0, 0x0b, 0xbd, 0xe1, 0xb2, 0xe9, 0x98, 0x0d, 0x52, 0x59, 0x5e, 0x26,
- 0xac, 0xe2, 0xe1, 0x17, 0x15, 0x7c, 0x3b, 0x3a, 0xd4, 0x35, 0x62, 0x71, 0xc6, 0xa7, 0x2b, 0xda,
- 0xe6, 0xa5, 0x9c, 0xde, 0x11, 0x7b, 0xa0, 0x75, 0x20, 0xbc, 0xe2, 0x71, 0xea, 0x3a, 0x7e, 0xc5,
- 0xc3, 0x2f, 0xf7, 0x0e, 0x26, 0xba, 0x45, 0xd7, 0x58, 0xe0, 0x8b, 0xc8, 0xaf, 0xf5, 0x16, 0x9e,
- 0xb4, 0x6d, 0x77, 0x55, 0xb1, 0xaf, 0x28, 0xf6, 0x58, 0x7a, 0x10, 0x2b, 0x36, 0x2a, 0x72, 0x99,
- 0xb0, 0x06, 0xa9, 0x78, 0xf8, 0xd5, 0xde, 0xca, 0x51, 0x4d, 0xa6, 0x4d, 0x6e, 0x56, 0x3c, 0xfc,
- 0x5a, 0x6f, 0xe5, 0xa9, 0xa0, 0xe5, 0x55, 0x45, 0x03, 0x39, 0x75, 0xa1, 0xfc, 0x7a, 0x4e, 0xef,
- 0xe4, 0x1d, 0x5d, 0x9a, 0x32, 0xdc, 0x0d, 0x6f, 0xe4, 0xf4, 0xb4, 0x49, 0xf7, 0x38, 0x73, 0x9d,
- 0x44, 0xa3, 0xbd, 0x99, 0xd3, 0x83, 0x6b, 0x5b, 0x16, 0x53, 0xcc, 0x5b, 0x39, 0x7d, 0x48, 0xde,
- 0x9a, 0x65, 0xe4, 0x26, 0x78, 0xbb, 0xdb, 0x56, 0x97, 0x48, 0x18, 0xd2, 0x3b, 0x5d, 0xf6, 0x53,
- 0xd1, 0x64, 0x96, 0xe9, 0xb8, 0x52, 0xea, 0x1b, 0x79, 0xb8, 0x49, 0x25, 0x15, 0xbf, 0x69, 0x9f,
- 0xca, 0xeb, 0x0f, 0x03, 0x7b, 0x00, 0x30, 0xb5, 0xe3, 0xbf, 0xd9, 0x5b, 0x34, 0x06, 0xbf, 0x95,
- 0x87, 0xb7, 0x68, 0x2c, 0xaa, 0xaa, 0xf2, 0xed, 0x3c, 0xbc, 0x45, 0x25, 0xa9, 0xb0, 0xef, 0xe4,
- 0xf5, 0x3b, 0x76, 0x04, 0x4c, 0x47, 0x9c, 0x07, 0xae, 0xe6, 0xe1, 0x45, 0x4d, 0x54, 0x26, 0xac,
- 0xe0, 0x77, 0x95, 0x58, 0x66, 0xd6, 0x54, 0x1c, 0xee, 0xda, 0x6e, 0xa3, 0x9d, 0x08, 0xef, 0x37,
- 0x5d, 0x24, 0x15, 0xaa, 0xb8, 0xdf, 0xe6, 0xf5, 0x15, 0x7e, 0xb4, 0x8b, 0x64, 0x5c, 0x9d, 0xdf,
- 0xe5, 0xe1, 0x73, 0x9a, 0x82, 0x63, 0xf2, 0xf7, 0xeb, 0xc8, 0x86, 0x8b, 0xcd, 0x4c, 0xc7, 0x5f,
- 0x26, 0x0c, 0xff, 0x41, 0xc9, 0x66, 0xc6, 0x58, 0x12, 0x26, 0x96, 0xc6, 0xff, 0xa8, 0xb4, 0xc7,
- 0xd1, 0xfe, 0x6e, 0xf8, 0x05, 0xca, 0x9b, 0x16, 0x33, 0x57, 0x2b, 0x4e, 0x03, 0xff, 0x49, 0xc9,
- 0x9f, 0x44, 0xb7, 0x76, 0x97, 0x4f, 0x5a, 0xfc, 0x39, 0xaf, 0x3f, 0x3e, 0x74, 0xb5, 0xa8, 0x38,
- 0x7c, 0xce, 0x5a, 0x24, 0x0d, 0xea, 0x8b, 0xbb, 0xfc, 0x1b, 0x79, 0x78, 0xae, 0xa5, 0x7d, 0xa4,
- 0x6d, 0xfe, 0xa2, 0xbc, 0x9c, 0x42, 0x47, 0x7a, 0x7a, 0x99, 0xb4, 0xac, 0x49, 0xce, 0x19, 0x5d,
- 0x0a, 0x38, 0xf1, 0xf1, 0x5f, 0x95, 0xab, 0xbb, 0xd0, 0xb1, 0x75, 0x5c, 0xa5, 0x0d, 0xff, 0x96,
- 0xd7, 0xa7, 0x85, 0xd4, 0x26, 0x58, 0xa4, 0x9e, 0x67, 0x93, 0x44, 0xef, 0x3c, 0x3c, 0x00, 0xbf,
- 0x6f, 0x23, 0x50, 0x51, 0x1f, 0x1d, 0x80, 0x3b, 0x3b, 0xa2, 0xe4, 0x6e, 0x7e, 0x64, 0x00, 0xde,
- 0x25, 0x31, 0x14, 0x36, 0xf6, 0xa3, 0x0a, 0x7b, 0x37, 0x1a, 0x4b, 0xdd, 0x9f, 0x5d, 0x87, 0x30,
- 0x37, 0x5c, 0x79, 0xb3, 0x2e, 0x66, 0xfc, 0x9c, 0x43, 0xb9, 0x1a, 0x00, 0x7f, 0x1f, 0xd0, 0x17,
- 0xbb, 0x03, 0xeb, 0x1a, 0x89, 0x6d, 0xf6, 0x0f, 0x65, 0x90, 0xa9, 0x5c, 0x87, 0x41, 0x95, 0xf0,
- 0x39, 0xc7, 0x0b, 0xb4, 0xa7, 0x7f, 0x2a, 0xc3, 0xf5, 0xc2, 0x53, 0x86, 0xc2, 0xdb, 0xbf, 0x94,
- 0xd1, 0x19, 0x74, 0x6a, 0x9d, 0xf0, 0xbc, 0x80, 0xfb, 0xe7, 0x08, 0x6b, 0x05, 0xdc, 0x14, 0x7f,
- 0x50, 0x6e, 0xff, 0xad, 0x14, 0x4e, 0xa3, 0xdb, 0xfe, 0x3f, 0x05, 0xe1, 0xff, 0x4d, 0x65, 0x7d,
- 0x37, 0x3a, 0xbe, 0xbe, 0xf5, 0x79, 0xea, 0x50, 0xe5, 0xf7, 0x2d, 0x65, 0x79, 0x07, 0x3a, 0xdc,
- 0x9f, 0xa5, 0xf0, 0xf7, 0xb6, 0xb2, 0xba, 0x07, 0x9d, 0xec, 0x69, 0x35, 0x69, 0xdb, 0x51, 0xc0,
- 0x55, 0xa2, 0x2b, 0xfc, 0x4e, 0xbf, 0x4b, 0x93, 0x34, 0x16, 0x5e, 0xff, 0xd3, 0x6f, 0x96, 0xe2,
- 0x98, 0x10, 0xf0, 0xc4, 0xa2, 0xfe, 0xb7, 0xdf, 0x2c, 0xb5, 0xa5, 0xf0, 0xf7, 0x7e, 0xa3, 0x4f,
- 0x7f, 0x93, 0xb6, 0x5d, 0x09, 0x78, 0x22, 0xc5, 0x0f, 0x18, 0x7d, 0xfa, 0xd3, 0x96, 0xc2, 0xdf,
- 0x07, 0xfb, 0xf5, 0x17, 0x7e, 0xf4, 0x49, 0x36, 0xed, 0x87, 0xfa, 0xf5, 0xa7, 0x2d, 0x85, 0xbf,
- 0x0f, 0xf7, 0x6b, 0x35, 0x43, 0x1d, 0xd3, 0x56, 0xbe, 0x3e, 0x62, 0xc0, 0x03, 0x13, 0xb6, 0x12,
- 0x7e, 0x1e, 0x52, 0x16, 0x77, 0xa2, 0xa3, 0x9d, 0x16, 0x67, 0x49, 0x7b, 0xae, 0x65, 0x36, 0x48,
- 0x69, 0xcd, 0x73, 0x19, 0x4f, 0x6e, 0xfa, 0x47, 0x94, 0x5d, 0x66, 0xd0, 0x76, 0xb3, 0x13, 0xbe,
- 0x1e, 0xed, 0x99, 0x93, 0xb2, 0xa9, 0xb6, 0x9d, 0x7a, 0x95, 0x13, 0x7d, 0x5a, 0xff, 0x58, 0xcf,
- 0x9c, 0xb2, 0x56, 0xc2, 0xcf, 0xc7, 0x0d, 0x78, 0xa0, 0x77, 0x5a, 0xa4, 0x8a, 0xf7, 0x98, 0x32,
- 0xbb, 0x0d, 0x1d, 0xec, 0xc3, 0x4c, 0x78, 0x7a, 0xdc, 0x80, 0x47, 0x79, 0x64, 0x92, 0x18, 0xe5,
- 0x9f, 0x36, 0xe0, 0x51, 0x1e, 0x81, 0x8a, 0xfa, 0x8c, 0x01, 0x9f, 0x7a, 0xb4, 0xdc, 0x05, 0x93,
- 0xd7, 0x9b, 0xe2, 0xbd, 0xfe, 0x59, 0x03, 0x9e, 0xe7, 0x11, 0xa9, 0xb1, 0xcf, 0x19, 0xf0, 0xc5,
- 0x24, 0xfc, 0x50, 0x14, 0xb1, 0xd3, 0xd4, 0x6c, 0xa8, 0x0a, 0x7c, 0xde, 0x80, 0xef, 0x50, 0x19,
- 0x5c, 0x64, 0xfe, 0x05, 0xa5, 0x9c, 0x39, 0x2d, 0xeb, 0x50, 0x6b, 0x6b, 0x67, 0x89, 0xfe, 0xa9,
- 0xe3, 0x8b, 0x06, 0x7c, 0x60, 0x49, 0xd3, 0x42, 0xf7, 0x4b, 0x3d, 0x7b, 0x64, 0x9e, 0xae, 0x90,
- 0x45, 0xb2, 0xcc, 0x88, 0xdf, 0xac, 0x72, 0x93, 0xe9, 0x6e, 0x7c, 0xd2, 0x80, 0x8f, 0x16, 0xb0,
- 0x95, 0xf0, 0xf3, 0x65, 0xa3, 0xd7, 0xab, 0x24, 0x65, 0x11, 0xb7, 0xe2, 0x57, 0x94, 0x1b, 0xf0,
- 0x4d, 0x97, 0x31, 0x12, 0x5e, 0xbe, 0xda, 0x6f, 0x36, 0xa9, 0x46, 0xfc, 0x5a, 0xbf, 0xd9, 0xe8,
- 0x3e, 0xfc, 0xba, 0x01, 0x7f, 0x0a, 0x28, 0x65, 0x6e, 0xdc, 0xd7, 0x0c, 0xf8, 0x7e, 0x50, 0x4a,
- 0xde, 0xb7, 0x5f, 0x31, 0xf4, 0x67, 0x96, 0x2d, 0x19, 0x48, 0x9e, 0x26, 0x5e, 0xed, 0xd2, 0x27,
- 0x25, 0xd7, 0x17, 0x07, 0xe9, 0xe4, 0xbb, 0xf3, 0xd7, 0x06, 0x7c, 0xff, 0x49, 0xa0, 0x22, 0x81,
- 0xd7, 0x0c, 0xf8, 0xfe, 0x53, 0x4a, 0x7c, 0x58, 0x78, 0xbd, 0xcb, 0xee, 0x98, 0xa2, 0x8e, 0xe9,
- 0xd4, 0x93, 0x07, 0xa7, 0x1f, 0x0c, 0xc2, 0xbb, 0x43, 0x92, 0x0a, 0xfb, 0xe1, 0x20, 0x7c, 0x73,
- 0x89, 0x05, 0xe3, 0xa2, 0xfc, 0x68, 0x10, 0xbe, 0xb9, 0x48, 0x36, 0x06, 0x7f, 0x3c, 0x08, 0xdf,
- 0xae, 0x24, 0x28, 0x2b, 0xf8, 0x74, 0x6f, 0xb9, 0xf8, 0x76, 0xf5, 0x93, 0x41, 0xf8, 0xaa, 0xa1,
- 0x40, 0x79, 0x18, 0x2f, 0xfb, 0x0d, 0xfc, 0xcc, 0x20, 0x7c, 0xd5, 0x90, 0x68, 0x85, 0x59, 0x11,
- 0xf7, 0x6c, 0x6f, 0xdf, 0xd1, 0x8f, 0xb4, 0x02, 0xfc, 0x69, 0x6f, 0x41, 0xbd, 0x30, 0x3f, 0x93,
- 0x31, 0x4e, 0x9c, 0x46, 0xd7, 0xaf, 0x52, 0x46, 0x2e, 0x52, 0x67, 0x78, 0xef, 0x78, 0xf4, 0x4b,
- 0xff, 0xb8, 0xfa, 0xa5, 0x7f, 0xbc, 0xe4, 0x04, 0xad, 0xf0, 0xe7, 0x12, 0xf9, 0x95, 0x60, 0xe4,
- 0xb9, 0x87, 0x06, 0x46, 0x73, 0x63, 0x43, 0x8b, 0xd7, 0x09, 0x9b, 0x39, 0x67, 0xe2, 0x5e, 0x34,
- 0x14, 0x5a, 0xbb, 0x01, 0xef, 0xc7, 0xfc, 0x79, 0x69, 0x1e, 0xba, 0xac, 0x04, 0x7c, 0x62, 0x16,
- 0x6d, 0x0a, 0xed, 0x2d, 0x31, 0xad, 0xfa, 0x8c, 0xe1, 0x05, 0x29, 0xb2, 0x41, 0x58, 0x86, 0x63,
- 0x6e, 0xce, 0x99, 0x98, 0x43, 0x9b, 0x13, 0x42, 0x7d, 0x86, 0xf3, 0xa2, 0x54, 0xda, 0xa8, 0x95,
- 0x44, 0x4c, 0x67, 0xd0, 0x0d, 0xa1, 0x14, 0xa7, 0x4e, 0xbb, 0x1f, 0x95, 0x97, 0xa4, 0x4a, 0x58,
- 0x89, 0x1a, 0x75, 0xda, 0x13, 0xf3, 0xe8, 0xc6, 0x50, 0x61, 0xc9, 0x75, 0xb9, 0xed, 0x9a, 0x16,
- 0x61, 0xfd, 0xe8, 0xbc, 0x2c, 0x75, 0xc2, 0x44, 0xa6, 0xb4, 0xe9, 0x44, 0x11, 0x85, 0x99, 0x5e,
- 0x74, 0xdc, 0x8b, 0xcb, 0x7e, 0xab, 0x1f, 0xa5, 0x6b, 0x52, 0x29, 0xcc, 0x63, 0xc1, 0x9d, 0xf1,
- 0x5b, 0x53, 0x77, 0xa0, 0xfd, 0x75, 0xb7, 0x35, 0xee, 0x9b, 0xdc, 0xf5, 0x9b, 0xd4, 0x36, 0x97,
- 0x7c, 0xf5, 0xff, 0x79, 0xd8, 0x74, 0x49, 0x4b, 0x4d, 0x6d, 0xaa, 0x85, 0x7f, 0x94, 0x9d, 0xf3,
- 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa3, 0x69, 0x67, 0x5d, 0x1f, 0x22, 0x00, 0x00,
-}
diff --git a/accounts/usbwallet/trezor/messages.proto b/accounts/usbwallet/trezor/messages.proto
deleted file mode 100644
index 3e0482e344..0000000000
--- a/accounts/usbwallet/trezor/messages.proto
+++ /dev/null
@@ -1,264 +0,0 @@
-// This file originates from the SatoshiLabs Trezor `common` repository at:
-// https://github.com/trezor/trezor-common/blob/master/protob/messages.proto
-// dated 28.05.2019, commit 893fd219d4a01bcffa0cd9cfa631856371ec5aa9.
-
-syntax = "proto2";
-package hw.trezor.messages;
-
-/**
- * Messages for TREZOR communication
- */
-
-// Sugar for easier handling in Java
-option java_package = "com.satoshilabs.trezor.lib.protobuf";
-option java_outer_classname = "TrezorMessage";
-
-import "google/protobuf/descriptor.proto";
-
-/**
- * Options for specifying message direction and type of wire (normal/debug)
- */
-extend google.protobuf.EnumValueOptions {
- optional bool wire_in = 50002; // message can be transmitted via wire from PC to TREZOR
- optional bool wire_out = 50003; // message can be transmitted via wire from TREZOR to PC
- optional bool wire_debug_in = 50004; // message can be transmitted via debug wire from PC to TREZOR
- optional bool wire_debug_out = 50005; // message can be transmitted via debug wire from TREZOR to PC
- optional bool wire_tiny = 50006; // message is handled by TREZOR when the USB stack is in tiny mode
- optional bool wire_bootloader = 50007; // message is only handled by TREZOR Bootloader
- optional bool wire_no_fsm = 50008; // message is not handled by TREZOR unless the USB stack is in tiny mode
-}
-
-/**
- * Mapping between TREZOR wire identifier (uint) and a protobuf message
- */
-enum MessageType {
-
- // Management
- MessageType_Initialize = 0 [(wire_in) = true, (wire_tiny) = true];
- MessageType_Ping = 1 [(wire_in) = true];
- MessageType_Success = 2 [(wire_out) = true];
- MessageType_Failure = 3 [(wire_out) = true];
- MessageType_ChangePin = 4 [(wire_in) = true];
- MessageType_WipeDevice = 5 [(wire_in) = true];
- MessageType_GetEntropy = 9 [(wire_in) = true];
- MessageType_Entropy = 10 [(wire_out) = true];
- MessageType_LoadDevice = 13 [(wire_in) = true];
- MessageType_ResetDevice = 14 [(wire_in) = true];
- MessageType_Features = 17 [(wire_out) = true];
- MessageType_PinMatrixRequest = 18 [(wire_out) = true];
- MessageType_PinMatrixAck = 19 [(wire_in) = true, (wire_tiny) = true, (wire_no_fsm) = true];
- MessageType_Cancel = 20 [(wire_in) = true, (wire_tiny) = true];
- MessageType_ClearSession = 24 [(wire_in) = true];
- MessageType_ApplySettings = 25 [(wire_in) = true];
- MessageType_ButtonRequest = 26 [(wire_out) = true];
- MessageType_ButtonAck = 27 [(wire_in) = true, (wire_tiny) = true, (wire_no_fsm) = true];
- MessageType_ApplyFlags = 28 [(wire_in) = true];
- MessageType_BackupDevice = 34 [(wire_in) = true];
- MessageType_EntropyRequest = 35 [(wire_out) = true];
- MessageType_EntropyAck = 36 [(wire_in) = true];
- MessageType_PassphraseRequest = 41 [(wire_out) = true];
- MessageType_PassphraseAck = 42 [(wire_in) = true, (wire_tiny) = true, (wire_no_fsm) = true];
- MessageType_PassphraseStateRequest = 77 [(wire_out) = true];
- MessageType_PassphraseStateAck = 78 [(wire_in) = true, (wire_tiny) = true, (wire_no_fsm) = true];
- MessageType_RecoveryDevice = 45 [(wire_in) = true];
- MessageType_WordRequest = 46 [(wire_out) = true];
- MessageType_WordAck = 47 [(wire_in) = true];
- MessageType_GetFeatures = 55 [(wire_in) = true];
- MessageType_SetU2FCounter = 63 [(wire_in) = true];
-
- // Bootloader
- MessageType_FirmwareErase = 6 [(wire_in) = true, (wire_bootloader) = true];
- MessageType_FirmwareUpload = 7 [(wire_in) = true, (wire_bootloader) = true];
- MessageType_FirmwareRequest = 8 [(wire_out) = true, (wire_bootloader) = true];
- MessageType_SelfTest = 32 [(wire_in) = true, (wire_bootloader) = true];
-
- // Bitcoin
- MessageType_GetPublicKey = 11 [(wire_in) = true];
- MessageType_PublicKey = 12 [(wire_out) = true];
- MessageType_SignTx = 15 [(wire_in) = true];
- MessageType_TxRequest = 21 [(wire_out) = true];
- MessageType_TxAck = 22 [(wire_in) = true];
- MessageType_GetAddress = 29 [(wire_in) = true];
- MessageType_Address = 30 [(wire_out) = true];
- MessageType_SignMessage = 38 [(wire_in) = true];
- MessageType_VerifyMessage = 39 [(wire_in) = true];
- MessageType_MessageSignature = 40 [(wire_out) = true];
-
- // Crypto
- MessageType_CipherKeyValue = 23 [(wire_in) = true];
- MessageType_CipheredKeyValue = 48 [(wire_out) = true];
- MessageType_SignIdentity = 53 [(wire_in) = true];
- MessageType_SignedIdentity = 54 [(wire_out) = true];
- MessageType_GetECDHSessionKey = 61 [(wire_in) = true];
- MessageType_ECDHSessionKey = 62 [(wire_out) = true];
- MessageType_CosiCommit = 71 [(wire_in) = true];
- MessageType_CosiCommitment = 72 [(wire_out) = true];
- MessageType_CosiSign = 73 [(wire_in) = true];
- MessageType_CosiSignature = 74 [(wire_out) = true];
-
- // Debug
- MessageType_DebugLinkDecision = 100 [(wire_debug_in) = true, (wire_tiny) = true, (wire_no_fsm) = true];
- MessageType_DebugLinkGetState = 101 [(wire_debug_in) = true, (wire_tiny) = true];
- MessageType_DebugLinkState = 102 [(wire_debug_out) = true];
- MessageType_DebugLinkStop = 103 [(wire_debug_in) = true];
- MessageType_DebugLinkLog = 104 [(wire_debug_out) = true];
- MessageType_DebugLinkMemoryRead = 110 [(wire_debug_in) = true];
- MessageType_DebugLinkMemory = 111 [(wire_debug_out) = true];
- MessageType_DebugLinkMemoryWrite = 112 [(wire_debug_in) = true];
- MessageType_DebugLinkFlashErase = 113 [(wire_debug_in) = true];
-
- // Ethereum
- MessageType_EthereumGetPublicKey = 450 [(wire_in) = true];
- MessageType_EthereumPublicKey = 451 [(wire_out) = true];
- MessageType_EthereumGetAddress = 56 [(wire_in) = true];
- MessageType_EthereumAddress = 57 [(wire_out) = true];
- MessageType_EthereumSignTx = 58 [(wire_in) = true];
- MessageType_EthereumTxRequest = 59 [(wire_out) = true];
- MessageType_EthereumTxAck = 60 [(wire_in) = true];
- MessageType_EthereumSignMessage = 64 [(wire_in) = true];
- MessageType_EthereumVerifyMessage = 65 [(wire_in) = true];
- MessageType_EthereumMessageSignature = 66 [(wire_out) = true];
-
- // NEM
- MessageType_NEMGetAddress = 67 [(wire_in) = true];
- MessageType_NEMAddress = 68 [(wire_out) = true];
- MessageType_NEMSignTx = 69 [(wire_in) = true];
- MessageType_NEMSignedTx = 70 [(wire_out) = true];
- MessageType_NEMDecryptMessage = 75 [(wire_in) = true];
- MessageType_NEMDecryptedMessage = 76 [(wire_out) = true];
-
- // Lisk
- MessageType_LiskGetAddress = 114 [(wire_in) = true];
- MessageType_LiskAddress = 115 [(wire_out) = true];
- MessageType_LiskSignTx = 116 [(wire_in) = true];
- MessageType_LiskSignedTx = 117 [(wire_out) = true];
- MessageType_LiskSignMessage = 118 [(wire_in) = true];
- MessageType_LiskMessageSignature = 119 [(wire_out) = true];
- MessageType_LiskVerifyMessage = 120 [(wire_in) = true];
- MessageType_LiskGetPublicKey = 121 [(wire_in) = true];
- MessageType_LiskPublicKey = 122 [(wire_out) = true];
-
- // Tezos
- MessageType_TezosGetAddress = 150 [(wire_in) = true];
- MessageType_TezosAddress = 151 [(wire_out) = true];
- MessageType_TezosSignTx = 152 [(wire_in) = true];
- MessageType_TezosSignedTx = 153 [(wire_out) = true];
- MessageType_TezosGetPublicKey = 154 [(wire_in) = true];
- MessageType_TezosPublicKey = 155 [(wire_out) = true];
-
- // Stellar
- MessageType_StellarSignTx = 202 [(wire_in) = true];
- MessageType_StellarTxOpRequest = 203 [(wire_out) = true];
- MessageType_StellarGetAddress = 207 [(wire_in) = true];
- MessageType_StellarAddress = 208 [(wire_out) = true];
- MessageType_StellarCreateAccountOp = 210 [(wire_in) = true];
- MessageType_StellarPaymentOp = 211 [(wire_in) = true];
- MessageType_StellarPathPaymentOp = 212 [(wire_in) = true];
- MessageType_StellarManageOfferOp = 213 [(wire_in) = true];
- MessageType_StellarCreatePassiveOfferOp = 214 [(wire_in) = true];
- MessageType_StellarSetOptionsOp = 215 [(wire_in) = true];
- MessageType_StellarChangeTrustOp = 216 [(wire_in) = true];
- MessageType_StellarAllowTrustOp = 217 [(wire_in) = true];
- MessageType_StellarAccountMergeOp = 218 [(wire_in) = true];
- // omitted: StellarInflationOp is not a supported operation, would be 219
- MessageType_StellarManageDataOp = 220 [(wire_in) = true];
- MessageType_StellarBumpSequenceOp = 221 [(wire_in) = true];
- MessageType_StellarSignedTx = 230 [(wire_out) = true];
-
- // TRON
- MessageType_TronGetAddress = 250 [(wire_in) = true];
- MessageType_TronAddress = 251 [(wire_out) = true];
- MessageType_TronSignTx = 252 [(wire_in) = true];
- MessageType_TronSignedTx = 253 [(wire_out) = true];
-
- // Cardano
- // dropped Sign/VerifyMessage ids 300-302
- MessageType_CardanoSignTx = 303 [(wire_in) = true];
- MessageType_CardanoTxRequest = 304 [(wire_out) = true];
- MessageType_CardanoGetPublicKey = 305 [(wire_in) = true];
- MessageType_CardanoPublicKey = 306 [(wire_out) = true];
- MessageType_CardanoGetAddress = 307 [(wire_in) = true];
- MessageType_CardanoAddress = 308 [(wire_out) = true];
- MessageType_CardanoTxAck = 309 [(wire_in) = true];
- MessageType_CardanoSignedTx = 310 [(wire_out) = true];
-
- // Ontology
- MessageType_OntologyGetAddress = 350 [(wire_in) = true];
- MessageType_OntologyAddress = 351 [(wire_out) = true];
- MessageType_OntologyGetPublicKey = 352 [(wire_in) = true];
- MessageType_OntologyPublicKey = 353 [(wire_out) = true];
- MessageType_OntologySignTransfer = 354 [(wire_in) = true];
- MessageType_OntologySignedTransfer = 355 [(wire_out) = true];
- MessageType_OntologySignWithdrawOng = 356 [(wire_in) = true];
- MessageType_OntologySignedWithdrawOng = 357 [(wire_out) = true];
- MessageType_OntologySignOntIdRegister = 358 [(wire_in) = true];
- MessageType_OntologySignedOntIdRegister = 359 [(wire_out) = true];
- MessageType_OntologySignOntIdAddAttributes = 360 [(wire_in) = true];
- MessageType_OntologySignedOntIdAddAttributes = 361 [(wire_out) = true];
-
- // Ripple
- MessageType_RippleGetAddress = 400 [(wire_in) = true];
- MessageType_RippleAddress = 401 [(wire_out) = true];
- MessageType_RippleSignTx = 402 [(wire_in) = true];
- MessageType_RippleSignedTx = 403 [(wire_in) = true];
-
- // Monero
- MessageType_MoneroTransactionInitRequest = 501 [(wire_out) = true];
- MessageType_MoneroTransactionInitAck = 502 [(wire_out) = true];
- MessageType_MoneroTransactionSetInputRequest = 503 [(wire_out) = true];
- MessageType_MoneroTransactionSetInputAck = 504 [(wire_out) = true];
- MessageType_MoneroTransactionInputsPermutationRequest = 505 [(wire_out) = true];
- MessageType_MoneroTransactionInputsPermutationAck = 506 [(wire_out) = true];
- MessageType_MoneroTransactionInputViniRequest = 507 [(wire_out) = true];
- MessageType_MoneroTransactionInputViniAck = 508 [(wire_out) = true];
- MessageType_MoneroTransactionAllInputsSetRequest = 509 [(wire_out) = true];
- MessageType_MoneroTransactionAllInputsSetAck = 510 [(wire_out) = true];
- MessageType_MoneroTransactionSetOutputRequest = 511 [(wire_out) = true];
- MessageType_MoneroTransactionSetOutputAck = 512 [(wire_out) = true];
- MessageType_MoneroTransactionAllOutSetRequest = 513 [(wire_out) = true];
- MessageType_MoneroTransactionAllOutSetAck = 514 [(wire_out) = true];
- MessageType_MoneroTransactionSignInputRequest = 515 [(wire_out) = true];
- MessageType_MoneroTransactionSignInputAck = 516 [(wire_out) = true];
- MessageType_MoneroTransactionFinalRequest = 517 [(wire_out) = true];
- MessageType_MoneroTransactionFinalAck = 518 [(wire_out) = true];
- MessageType_MoneroKeyImageExportInitRequest = 530 [(wire_out) = true];
- MessageType_MoneroKeyImageExportInitAck = 531 [(wire_out) = true];
- MessageType_MoneroKeyImageSyncStepRequest = 532 [(wire_out) = true];
- MessageType_MoneroKeyImageSyncStepAck = 533 [(wire_out) = true];
- MessageType_MoneroKeyImageSyncFinalRequest = 534 [(wire_out) = true];
- MessageType_MoneroKeyImageSyncFinalAck = 535 [(wire_out) = true];
- MessageType_MoneroGetAddress = 540 [(wire_in) = true];
- MessageType_MoneroAddress = 541 [(wire_out) = true];
- MessageType_MoneroGetWatchKey = 542 [(wire_in) = true];
- MessageType_MoneroWatchKey = 543 [(wire_out) = true];
- MessageType_DebugMoneroDiagRequest = 546 [(wire_in) = true];
- MessageType_DebugMoneroDiagAck = 547 [(wire_out) = true];
- MessageType_MoneroGetTxKeyRequest = 550 [(wire_in) = true];
- MessageType_MoneroGetTxKeyAck = 551 [(wire_out) = true];
- MessageType_MoneroLiveRefreshStartRequest = 552 [(wire_in) = true];
- MessageType_MoneroLiveRefreshStartAck = 553 [(wire_out) = true];
- MessageType_MoneroLiveRefreshStepRequest = 554 [(wire_in) = true];
- MessageType_MoneroLiveRefreshStepAck = 555 [(wire_out) = true];
- MessageType_MoneroLiveRefreshFinalRequest = 556 [(wire_in) = true];
- MessageType_MoneroLiveRefreshFinalAck = 557 [(wire_out) = true];
-
- // EOS
- MessageType_EosGetPublicKey = 600 [(wire_in) = true];
- MessageType_EosPublicKey = 601 [(wire_out) = true];
- MessageType_EosSignTx = 602 [(wire_in) = true];
- MessageType_EosTxActionRequest = 603 [(wire_out) = true];
- MessageType_EosTxActionAck = 604 [(wire_in) = true];
- MessageType_EosSignedTx = 605 [(wire_out) = true];
-
- // Binance
- MessageType_BinanceGetAddress = 700 [(wire_in) = true];
- MessageType_BinanceAddress = 701 [(wire_out) = true];
- MessageType_BinanceGetPublicKey = 702 [(wire_in) = true];
- MessageType_BinancePublicKey = 703 [(wire_out) = true];
- MessageType_BinanceSignTx = 704 [(wire_in) = true];
- MessageType_BinanceTxRequest = 705 [(wire_out) = true];
- MessageType_BinanceTransferMsg = 706 [(wire_in) = true];
- MessageType_BinanceOrderMsg = 707 [(wire_in) = true];
- MessageType_BinanceCancelMsg = 708 [(wire_in) = true];
- MessageType_BinanceSignedTx = 709 [(wire_out) = true];
-}
diff --git a/accounts/usbwallet/trezor/trezor.go b/accounts/usbwallet/trezor/trezor.go
deleted file mode 100644
index 7e756e609b..0000000000
--- a/accounts/usbwallet/trezor/trezor.go
+++ /dev/null
@@ -1,70 +0,0 @@
-// 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 .
-
-// This file contains the implementation for interacting with the Trezor hardware
-// wallets. The wire protocol spec can be found on the SatoshiLabs website:
-// https://wiki.trezor.io/Developers_guide-Message_Workflows
-
-// !!! STAHP !!!
-//
-// Before you touch the protocol files, you need to be aware of a breaking change
-// that occurred between firmware versions 1.7.3->1.8.0 (Model One) and 2.0.10->
-// 2.1.0 (Model T). The Ethereum address representation was changed from the 20
-// byte binary blob to a 42 byte hex string. The upstream protocol buffer files
-// only support the new format, so blindly pulling in a new spec will break old
-// devices!
-//
-// The Trezor devs had the foresight to add the string version as a new message
-// code instead of replacing the binary one. This means that the proto file can
-// actually define both the old and the new versions as optional. Please ensure
-// that you add back the old addresses everywhere (to avoid name clash. use the
-// addressBin and addressHex names).
-//
-// If in doubt, reach out to @karalabe.
-
-// To regenerate the protocol files in this package:
-// - Download the latest protoc https://github.com/protocolbuffers/protobuf/releases
-// - Build with the usual `./configure && make` and ensure it's on your $PATH
-// - Delete all the .proto and .pb.go files, pull in fresh ones from Trezor
-// - Grab the latest Go plugin `go get -u github.com/golang/protobuf/protoc-gen-go`
-// - Vendor in the latest Go plugin `govendor fetch github.com/golang/protobuf/...`
-
-//go:generate protoc -I/usr/local/include:. --go_out=import_path=trezor:. messages.proto messages-common.proto messages-management.proto messages-ethereum.proto
-
-// Package trezor contains the wire protocol.
-package trezor
-
-import (
- "reflect"
-
- "github.com/golang/protobuf/proto"
-)
-
-// Type returns the protocol buffer type number of a specific message. If the
-// message is nil, this method panics!
-func Type(msg proto.Message) uint16 {
- return uint16(MessageType_value["MessageType_"+reflect.TypeOf(msg).Elem().Name()])
-}
-
-// Name returns the friendly message type name of a specific protocol buffer
-// type number.
-func Name(kind uint16) string {
- name := MessageType_name[int32(kind)]
- if len(name) < 12 {
- return name
- }
- return name[12:]
-}
diff --git a/accounts/usbwallet/wallet.go b/accounts/usbwallet/wallet.go
deleted file mode 100644
index 69083dc893..0000000000
--- a/accounts/usbwallet/wallet.go
+++ /dev/null
@@ -1,643 +0,0 @@
-// 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 usbwallet implements support for USB hardware wallets.
-package usbwallet
-
-import (
- "context"
- "fmt"
- "io"
- "math/big"
- "sync"
- "time"
-
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/accounts"
- "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"
- "github.com/karalabe/usb"
-)
-
-// Maximum time between wallet health checks to detect USB unplugs.
-const heartbeatCycle = time.Second
-
-// Minimum time to wait between self derivation attempts, even it the user is
-// requesting accounts like crazy.
-const selfDeriveThrottling = time.Second
-
-// driver defines the vendor specific functionality hardware wallets instances
-// must implement to allow using them with the wallet lifecycle management.
-type driver interface {
- // Status returns a textual status to aid the user in the current state of the
- // wallet. It also returns an error indicating any failure the wallet might have
- // encountered.
- Status() (string, error)
-
- // Open initializes access to a wallet instance. The passphrase parameter may
- // or may not be used by the implementation of a particular wallet instance.
- Open(device io.ReadWriter, passphrase string) error
-
- // Close releases any resources held by an open wallet instance.
- Close() error
-
- // Heartbeat performs a sanity check against the hardware wallet to see if it
- // is still online and healthy.
- Heartbeat() error
-
- // Derive sends a derivation request to the USB device and returns the Ethereum
- // address located on that path.
- Derive(path accounts.DerivationPath) (common.Address, error)
-
- // SignTx sends the transaction to the USB device and waits for the user to confirm
- // or deny the transaction.
- SignTx(path accounts.DerivationPath, tx *types.Transaction, chainID *big.Int) (common.Address, *types.Transaction, error)
-
- SignTypedMessage(path accounts.DerivationPath, messageHash []byte, domainHash []byte) ([]byte, error)
-}
-
-// wallet represents the common functionality shared by all USB hardware
-// wallets to prevent reimplementing the same complex maintenance mechanisms
-// for different vendors.
-type wallet struct {
- hub *Hub // USB hub scanning
- driver driver // Hardware implementation of the low level device operations
- url *accounts.URL // Textual URL uniquely identifying this wallet
-
- info usb.DeviceInfo // Known USB device infos about the wallet
- device usb.Device // USB device advertising itself as a hardware wallet
-
- accounts []accounts.Account // List of derive accounts pinned on the hardware wallet
- paths map[common.Address]accounts.DerivationPath // Known derivation paths for signing operations
-
- deriveNextPaths []accounts.DerivationPath // Next derivation paths for account auto-discovery (multiple bases supported)
- deriveNextAddrs []common.Address // Next derived account addresses for auto-discovery (multiple bases supported)
- deriveChain ethereum.ChainStateReader // Blockchain state reader to discover used account with
- deriveReq chan chan struct{} // Channel to request a self-derivation on
- deriveQuit chan chan error // Channel to terminate the self-deriver with
-
- healthQuit chan chan error
-
- // Locking a hardware wallet is a bit special. Since hardware devices are lower
- // performing, any communication with them might take a non negligible amount of
- // time. Worse still, waiting for user confirmation can take arbitrarily long,
- // but exclusive communication must be upheld during. Locking the entire wallet
- // in the mean time however would stall any parts of the system that don't want
- // to communicate, just read some state (e.g. list the accounts).
- //
- // As such, a hardware wallet needs two locks to function correctly. A state
- // lock can be used to protect the wallet's software-side internal state, which
- // must not be held exclusively during hardware communication. A communication
- // lock can be used to achieve exclusive access to the device itself, this one
- // however should allow "skipping" waiting for operations that might want to
- // use the device, but can live without too (e.g. account self-derivation).
- //
- // Since we have two locks, it's important to know how to properly use them:
- // - Communication requires the `device` to not change, so obtaining the
- // commsLock should be done after having a stateLock.
- // - Communication must not disable read access to the wallet state, so it
- // must only ever hold a *read* lock to stateLock.
- commsLock chan struct{} // Mutex (buf=1) for the USB comms without keeping the state locked
- stateLock sync.RWMutex // Protects read and write access to the wallet struct fields
-
- log log.Logger // Contextual logger to tag the base with its id
-}
-
-// URL implements accounts.Wallet, returning the URL of the USB hardware device.
-func (w *wallet) URL() accounts.URL {
- return *w.url // Immutable, no need for a lock
-}
-
-// Status implements accounts.Wallet, returning a custom status message from the
-// underlying vendor-specific hardware wallet implementation.
-func (w *wallet) Status() (string, error) {
- w.stateLock.RLock() // No device communication, state lock is enough
- defer w.stateLock.RUnlock()
-
- status, failure := w.driver.Status()
- if w.device == nil {
- return "Closed", failure
- }
- return status, failure
-}
-
-// Open implements accounts.Wallet, attempting to open a USB connection to the
-// hardware wallet.
-func (w *wallet) Open(passphrase string) error {
- w.stateLock.Lock() // State lock is enough since there's no connection yet at this point
- defer w.stateLock.Unlock()
-
- // If the device was already opened once, refuse to try again
- if w.paths != nil {
- return accounts.ErrWalletAlreadyOpen
- }
- // Make sure the actual device connection is done only once
- if w.device == nil {
- device, err := w.info.Open()
- if err != nil {
- return err
- }
- w.device = device
- w.commsLock = make(chan struct{}, 1)
- w.commsLock <- struct{}{} // Enable lock
- }
- // Delegate device initialization to the underlying driver
- if err := w.driver.Open(w.device, passphrase); err != nil {
- return err
- }
- // Connection successful, start life-cycle management
- w.paths = make(map[common.Address]accounts.DerivationPath)
-
- w.deriveReq = make(chan chan struct{})
- w.deriveQuit = make(chan chan error)
- w.healthQuit = make(chan chan error)
-
- go w.heartbeat()
- go w.selfDerive()
-
- // Notify anyone listening for wallet events that a new device is accessible
- go w.hub.updateFeed.Send(accounts.WalletEvent{Wallet: w, Kind: accounts.WalletOpened})
-
- return nil
-}
-
-// heartbeat is a health check loop for the USB wallets to periodically verify
-// whether they are still present or if they malfunctioned.
-func (w *wallet) heartbeat() {
- w.log.Debug("USB wallet health-check started")
- defer w.log.Debug("USB wallet health-check stopped")
-
- // Execute heartbeat checks until termination or error
- var (
- errc chan error
- err error
- )
- for errc == nil && err == nil {
- // Wait until termination is requested or the heartbeat cycle arrives
- select {
- case errc = <-w.healthQuit:
- // Termination requested
- continue
- case <-time.After(heartbeatCycle):
- // Heartbeat time
- }
- // Execute a tiny data exchange to see responsiveness
- w.stateLock.RLock()
- if w.device == nil {
- // Terminated while waiting for the lock
- w.stateLock.RUnlock()
- continue
- }
- <-w.commsLock // Don't lock state while resolving version
- err = w.driver.Heartbeat()
- w.commsLock <- struct{}{}
- w.stateLock.RUnlock()
-
- if err != nil {
- w.stateLock.Lock() // Lock state to tear the wallet down
- w.close()
- w.stateLock.Unlock()
- }
- // Ignore non hardware related errors
- err = nil
- }
- // In case of error, wait for termination
- if err != nil {
- w.log.Debug("USB wallet health-check failed", "err", err)
- errc = <-w.healthQuit
- }
- errc <- err
-}
-
-// Close implements accounts.Wallet, closing the USB connection to the device.
-func (w *wallet) Close() error {
- // Ensure the wallet was opened
- w.stateLock.RLock()
- hQuit, dQuit := w.healthQuit, w.deriveQuit
- w.stateLock.RUnlock()
-
- // Terminate the health checks
- var herr error
- if hQuit != nil {
- errc := make(chan error)
- hQuit <- errc
- herr = <-errc // Save for later, we *must* close the USB
- }
- // Terminate the self-derivations
- var derr error
- if dQuit != nil {
- errc := make(chan error)
- dQuit <- errc
- derr = <-errc // Save for later, we *must* close the USB
- }
- // Terminate the device connection
- w.stateLock.Lock()
- defer w.stateLock.Unlock()
-
- w.healthQuit = nil
- w.deriveQuit = nil
- w.deriveReq = nil
-
- if err := w.close(); err != nil {
- return err
- }
- if herr != nil {
- return herr
- }
- return derr
-}
-
-// close is the internal wallet closer that terminates the USB connection and
-// resets all the fields to their defaults.
-//
-// Note, close assumes the state lock is held!
-func (w *wallet) close() error {
- // Allow duplicate closes, especially for health-check failures
- if w.device == nil {
- return nil
- }
- // Close the device, clear everything, then return
- w.device.Close()
- w.device = nil
-
- w.accounts, w.paths = nil, nil
- return w.driver.Close()
-}
-
-// Accounts implements accounts.Wallet, returning the list of accounts pinned to
-// the USB hardware wallet. If self-derivation was enabled, the account list is
-// periodically expanded based on current chain state.
-func (w *wallet) Accounts() []accounts.Account {
- // Attempt self-derivation if it's running
- reqc := make(chan struct{}, 1)
- select {
- case w.deriveReq <- reqc:
- // Self-derivation request accepted, wait for it
- <-reqc
- default:
- // Self-derivation offline, throttled or busy, skip
- }
- // Return whatever account list we ended up with
- w.stateLock.RLock()
- defer w.stateLock.RUnlock()
-
- cpy := make([]accounts.Account, len(w.accounts))
- copy(cpy, w.accounts)
- return cpy
-}
-
-// selfDerive is an account derivation loop that upon request attempts to find
-// new non-zero accounts.
-func (w *wallet) selfDerive() {
- w.log.Debug("USB wallet self-derivation started")
- defer w.log.Debug("USB wallet self-derivation stopped")
-
- // Execute self-derivations until termination or error
- var (
- reqc chan struct{}
- errc chan error
- err error
- )
- for errc == nil && err == nil {
- // Wait until either derivation or termination is requested
- select {
- case errc = <-w.deriveQuit:
- // Termination requested
- continue
- case reqc = <-w.deriveReq:
- // Account discovery requested
- }
- // Derivation needs a chain and device access, skip if either unavailable
- w.stateLock.RLock()
- if w.device == nil || w.deriveChain == nil {
- w.stateLock.RUnlock()
- reqc <- struct{}{}
- continue
- }
- select {
- case <-w.commsLock:
- default:
- w.stateLock.RUnlock()
- reqc <- struct{}{}
- continue
- }
- // Device lock obtained, derive the next batch of accounts
- var (
- accs []accounts.Account
- paths []accounts.DerivationPath
-
- nextPaths = append([]accounts.DerivationPath{}, w.deriveNextPaths...)
- nextAddrs = append([]common.Address{}, w.deriveNextAddrs...)
-
- context = context.Background()
- )
- for i := 0; i < len(nextAddrs); i++ {
- for empty := false; !empty; {
- // Retrieve the next derived Ethereum account
- if nextAddrs[i] == (common.Address{}) {
- if nextAddrs[i], err = w.driver.Derive(nextPaths[i]); err != nil {
- w.log.Warn("USB wallet account derivation failed", "err", err)
- break
- }
- }
- // Check the account's status against the current chain state
- var (
- balance *big.Int
- nonce uint64
- )
- balance, err = w.deriveChain.BalanceAt(context, nextAddrs[i], nil)
- if err != nil {
- w.log.Warn("USB wallet balance retrieval failed", "err", err)
- break
- }
- nonce, err = w.deriveChain.NonceAt(context, nextAddrs[i], nil)
- if err != nil {
- w.log.Warn("USB wallet nonce retrieval failed", "err", err)
- break
- }
- // We've just self-derived a new account, start tracking it locally
- // unless the account was empty.
- path := make(accounts.DerivationPath, len(nextPaths[i]))
- copy(path[:], nextPaths[i][:])
- if balance.Sign() == 0 && nonce == 0 {
- empty = true
- // If it indeed was empty, make a log output for it anyway. In the case
- // of legacy-ledger, the first account on the legacy-path will
- // be shown to the user, even if we don't actively track it
- if i < len(nextAddrs)-1 {
- w.log.Info("Skipping tracking first account on legacy path, use personal.deriveAccount(,, false) to track",
- "path", path, "address", nextAddrs[i])
- break
- }
- }
- paths = append(paths, path)
- account := accounts.Account{
- Address: nextAddrs[i],
- URL: accounts.URL{Scheme: w.url.Scheme, Path: fmt.Sprintf("%s/%s", w.url.Path, path)},
- }
- accs = append(accs, account)
-
- // Display a log message to the user for new (or previously empty accounts)
- if _, known := w.paths[nextAddrs[i]]; !known || (!empty && nextAddrs[i] == w.deriveNextAddrs[i]) {
- w.log.Info("USB wallet discovered new account", "address", nextAddrs[i], "path", path, "balance", balance, "nonce", nonce)
- }
- // Fetch the next potential account
- if !empty {
- nextAddrs[i] = common.Address{}
- nextPaths[i][len(nextPaths[i])-1]++
- }
- }
- }
- // Self derivation complete, release device lock
- w.commsLock <- struct{}{}
- w.stateLock.RUnlock()
-
- // Insert any accounts successfully derived
- w.stateLock.Lock()
- for i := 0; i < len(accs); i++ {
- if _, ok := w.paths[accs[i].Address]; !ok {
- w.accounts = append(w.accounts, accs[i])
- w.paths[accs[i].Address] = paths[i]
- }
- }
- // Shift the self-derivation forward
- // TODO(karalabe): don't overwrite changes from wallet.SelfDerive
- w.deriveNextAddrs = nextAddrs
- w.deriveNextPaths = nextPaths
- w.stateLock.Unlock()
-
- // Notify the user of termination and loop after a bit of time (to avoid trashing)
- reqc <- struct{}{}
- if err == nil {
- select {
- case errc = <-w.deriveQuit:
- // Termination requested, abort
- case <-time.After(selfDeriveThrottling):
- // Waited enough, willing to self-derive again
- }
- }
- }
- // In case of error, wait for termination
- if err != nil {
- w.log.Debug("USB wallet self-derivation failed", "err", err)
- errc = <-w.deriveQuit
- }
- errc <- err
-}
-
-// Contains implements accounts.Wallet, returning whether a particular account is
-// or is not pinned into this wallet instance. Although we could attempt to resolve
-// unpinned accounts, that would be an non-negligible hardware operation.
-func (w *wallet) Contains(account accounts.Account) bool {
- w.stateLock.RLock()
- defer w.stateLock.RUnlock()
-
- _, exists := w.paths[account.Address]
- return exists
-}
-
-// Derive implements accounts.Wallet, deriving a new account at the specific
-// derivation path. If pin is set to true, the account will be added to the list
-// of tracked accounts.
-func (w *wallet) Derive(path accounts.DerivationPath, pin bool) (accounts.Account, error) {
- // Try to derive the actual account and update its URL if successful
- w.stateLock.RLock() // Avoid device disappearing during derivation
-
- if w.device == nil {
- w.stateLock.RUnlock()
- return accounts.Account{}, accounts.ErrWalletClosed
- }
- <-w.commsLock // Avoid concurrent hardware access
- address, err := w.driver.Derive(path)
- w.commsLock <- struct{}{}
-
- w.stateLock.RUnlock()
-
- // If an error occurred or no pinning was requested, return
- if err != nil {
- return accounts.Account{}, err
- }
- account := accounts.Account{
- Address: address,
- URL: accounts.URL{Scheme: w.url.Scheme, Path: fmt.Sprintf("%s/%s", w.url.Path, path)},
- }
- if !pin {
- return account, nil
- }
- // Pinning needs to modify the state
- w.stateLock.Lock()
- defer w.stateLock.Unlock()
-
- if w.device == nil {
- return accounts.Account{}, accounts.ErrWalletClosed
- }
-
- if _, ok := w.paths[address]; !ok {
- w.accounts = append(w.accounts, account)
- w.paths[address] = make(accounts.DerivationPath, len(path))
- copy(w.paths[address], path)
- }
- return account, nil
-}
-
-// SelfDerive sets a base account derivation path from which the wallet attempts
-// to discover non zero accounts and automatically add them to list of tracked
-// accounts.
-//
-// Note, self derivation will increment the last component of the specified path
-// opposed to descending into a child path to allow discovering accounts starting
-// from non zero components.
-//
-// Some hardware wallets switched derivation paths through their evolution, so
-// this method supports providing multiple bases to discover old user accounts
-// too. Only the last base will be used to derive the next empty account.
-//
-// You can disable automatic account discovery by calling SelfDerive with a nil
-// chain state reader.
-func (w *wallet) SelfDerive(bases []accounts.DerivationPath, chain ethereum.ChainStateReader) {
- w.stateLock.Lock()
- defer w.stateLock.Unlock()
-
- w.deriveNextPaths = make([]accounts.DerivationPath, len(bases))
- for i, base := range bases {
- w.deriveNextPaths[i] = make(accounts.DerivationPath, len(base))
- copy(w.deriveNextPaths[i][:], base[:])
- }
- w.deriveNextAddrs = make([]common.Address, len(bases))
- w.deriveChain = chain
-}
-
-// signHash implements accounts.Wallet, however signing arbitrary data is not
-// supported for hardware wallets, so this method will always return an error.
-func (w *wallet) signHash(account accounts.Account, hash []byte) ([]byte, error) {
- return nil, accounts.ErrNotSupported
-}
-
-// SignData signs keccak256(data). The mimetype parameter describes the type of data being signed
-func (w *wallet) SignData(account accounts.Account, mimeType string, data []byte) ([]byte, error) {
- // Unless we are doing 712 signing, simply dispatch to signHash
- if !(mimeType == accounts.MimetypeTypedData && len(data) == 66 && data[0] == 0x19 && data[1] == 0x01) {
- return w.signHash(account, crypto.Keccak256(data))
- }
-
- // dispatch to 712 signing if the mimetype is TypedData and the format matches
- w.stateLock.RLock() // Comms have own mutex, this is for the state fields
- defer w.stateLock.RUnlock()
-
- // If the wallet is closed, abort
- if w.device == nil {
- return nil, accounts.ErrWalletClosed
- }
- // Make sure the requested account is contained within
- path, ok := w.paths[account.Address]
- if !ok {
- return nil, accounts.ErrUnknownAccount
- }
- // All infos gathered and metadata checks out, request signing
- <-w.commsLock
- defer func() { w.commsLock <- struct{}{} }()
-
- // Ensure the device isn't screwed with while user confirmation is pending
- // TODO(karalabe): remove if hotplug lands on Windows
- w.hub.commsLock.Lock()
- w.hub.commsPend++
- w.hub.commsLock.Unlock()
-
- defer func() {
- w.hub.commsLock.Lock()
- w.hub.commsPend--
- w.hub.commsLock.Unlock()
- }()
- // Sign the transaction
- signature, err := w.driver.SignTypedMessage(path, data[2:34], data[34:66])
- if err != nil {
- return nil, err
- }
- return signature, nil
-}
-
-// SignDataWithPassphrase implements accounts.Wallet, attempting to sign the given
-// data with the given account using passphrase as extra authentication.
-// Since USB wallets don't rely on passphrases, these are silently ignored.
-func (w *wallet) SignDataWithPassphrase(account accounts.Account, passphrase, mimeType string, data []byte) ([]byte, error) {
- return w.SignData(account, mimeType, data)
-}
-
-func (w *wallet) SignText(account accounts.Account, text []byte) ([]byte, error) {
- return w.signHash(account, accounts.TextHash(text))
-}
-
-// SignTx implements accounts.Wallet. It sends the transaction over to the Ledger
-// wallet to request a confirmation from the user. It returns either the signed
-// transaction or a failure if the user denied the transaction.
-//
-// Note, if the version of the Ethereum application running on the Ledger wallet is
-// too old to sign EIP-155 transactions, but such is requested nonetheless, an error
-// will be returned opposed to silently signing in Homestead mode.
-func (w *wallet) SignTx(account accounts.Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
- w.stateLock.RLock() // Comms have own mutex, this is for the state fields
- defer w.stateLock.RUnlock()
-
- // If the wallet is closed, abort
- if w.device == nil {
- return nil, accounts.ErrWalletClosed
- }
- // Make sure the requested account is contained within
- path, ok := w.paths[account.Address]
- if !ok {
- return nil, accounts.ErrUnknownAccount
- }
- // All infos gathered and metadata checks out, request signing
- <-w.commsLock
- defer func() { w.commsLock <- struct{}{} }()
-
- // Ensure the device isn't screwed with while user confirmation is pending
- // TODO(karalabe): remove if hotplug lands on Windows
- w.hub.commsLock.Lock()
- w.hub.commsPend++
- w.hub.commsLock.Unlock()
-
- defer func() {
- w.hub.commsLock.Lock()
- w.hub.commsPend--
- w.hub.commsLock.Unlock()
- }()
- // Sign the transaction and verify the sender to avoid hardware fault surprises
- sender, signed, err := w.driver.SignTx(path, tx, chainID)
- if err != nil {
- return nil, err
- }
- if sender != account.Address {
- return nil, fmt.Errorf("signer mismatch: expected %s, got %s", account.Address.Hex(), sender.Hex())
- }
- return signed, nil
-}
-
-// SignTextWithPassphrase implements accounts.Wallet, however signing arbitrary
-// data is not supported for Ledger wallets, so this method will always return
-// an error.
-func (w *wallet) SignTextWithPassphrase(account accounts.Account, passphrase string, text []byte) ([]byte, error) {
- return w.SignText(account, accounts.TextHash(text))
-}
-
-// SignTxWithPassphrase implements accounts.Wallet, attempting to sign the given
-// transaction with the given account using passphrase as extra authentication.
-// Since USB wallets don't rely on passphrases, these are silently ignored.
-func (w *wallet) SignTxWithPassphrase(account accounts.Account, passphrase string, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
- return w.SignTx(account, tx, chainID)
-}