From 72826bb5adddedf0fd4fb9903e883d4c64fa18a6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?P=C3=A9ter=20Szil=C3=A1gyi?= Date: Wed, 16 Mar 2016 12:48:33 +0200 Subject: accounts/abi/bind, cmd/abigen: Go API generator around an EVM ABI --- accounts/abi/abi.go | 24 +--- accounts/abi/abi_test.go | 38 ++--- accounts/abi/bind/backend.go | 247 ++++++++++++++++++++++++++++++++ accounts/abi/bind/base.go | 130 +++++++++++++++++ accounts/abi/bind/bind.go | 317 +++++++++++++++++++++++++++++++++++++++++ accounts/abi/bind/bind_test.go | 140 ++++++++++++++++++ 6 files changed, 855 insertions(+), 41 deletions(-) create mode 100644 accounts/abi/bind/backend.go create mode 100644 accounts/abi/bind/base.go create mode 100644 accounts/abi/bind/bind.go create mode 100644 accounts/abi/bind/bind_test.go (limited to 'accounts/abi') diff --git a/accounts/abi/abi.go b/accounts/abi/abi.go index 673088f60..029d1b102 100644 --- a/accounts/abi/abi.go +++ b/accounts/abi/abi.go @@ -26,11 +26,6 @@ import ( "github.com/ethereum/go-ethereum/common" ) -// Executer is an executer method for performing state executions. It takes one -// argument which is the input data and expects output data to be returned as -// multiple 32 byte word length concatenated slice -type Executer func(datain []byte) []byte - // 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. @@ -169,21 +164,6 @@ func toGoType(i int, t Argument, output []byte) (interface{}, error) { return nil, fmt.Errorf("abi: unknown type %v", t.Type.T) } -// Call will unmarshal the output of the call in v. It will return an error if -// invalid type is given or if the output is too short to conform to the ABI -// spec. -// -// Call supports all of the available types and accepts a struct or an interface -// slice if the return is a tuple. -func (abi ABI) Call(executer Executer, v interface{}, name string, args ...interface{}) error { - callData, err := abi.Pack(name, args...) - if err != nil { - return err - } - - return abi.unmarshal(v, name, executer(callData)) -} - // these variable are used to determine certain types during type assertion for // assignment. var ( @@ -193,8 +173,8 @@ var ( r_byte = reflect.TypeOf(byte(0)) ) -// unmarshal output in v according to the abi specification -func (abi ABI) unmarshal(v interface{}, name string, output []byte) error { +// Unpack output in v according to the abi specification +func (abi ABI) Unpack(v interface{}, name string, output []byte) error { var method = abi.Methods[name] if len(output) == 0 { diff --git a/accounts/abi/abi_test.go b/accounts/abi/abi_test.go index 170f3f74b..66d2e1b39 100644 --- a/accounts/abi/abi_test.go +++ b/accounts/abi/abi_test.go @@ -579,7 +579,7 @@ func TestMultiReturnWithStruct(t *testing.T) { Int *big.Int String string } - err = abi.unmarshal(&inter, "multi", buff.Bytes()) + err = abi.Unpack(&inter, "multi", buff.Bytes()) if err != nil { t.Error(err) } @@ -597,7 +597,7 @@ func TestMultiReturnWithStruct(t *testing.T) { Int *big.Int } - err = abi.unmarshal(&reversed, "multi", buff.Bytes()) + err = abi.Unpack(&reversed, "multi", buff.Bytes()) if err != nil { t.Error(err) } @@ -629,7 +629,7 @@ func TestMultiReturnWithSlice(t *testing.T) { buff.Write(common.RightPadBytes([]byte(stringOut), 32)) var inter []interface{} - err = abi.unmarshal(&inter, "multi", buff.Bytes()) + err = abi.Unpack(&inter, "multi", buff.Bytes()) if err != nil { t.Error(err) } @@ -661,13 +661,13 @@ func TestMarshalArrays(t *testing.T) { output := common.LeftPadBytes([]byte{1}, 32) var bytes10 [10]byte - err = abi.unmarshal(&bytes10, "bytes32", output) + err = abi.Unpack(&bytes10, "bytes32", output) if err == nil || err.Error() != "abi: cannot unmarshal src (len=32) in to dst (len=10)" { t.Error("expected error or bytes32 not be assignable to bytes10:", err) } var bytes32 [32]byte - err = abi.unmarshal(&bytes32, "bytes32", output) + err = abi.Unpack(&bytes32, "bytes32", output) if err != nil { t.Error("didn't expect error:", err) } @@ -681,13 +681,13 @@ func TestMarshalArrays(t *testing.T) { ) var b10 B10 - err = abi.unmarshal(&b10, "bytes32", output) + err = abi.Unpack(&b10, "bytes32", output) if err == nil || err.Error() != "abi: cannot unmarshal src (len=32) in to dst (len=10)" { t.Error("expected error or bytes32 not be assignable to bytes10:", err) } var b32 B32 - err = abi.unmarshal(&b32, "bytes32", output) + err = abi.Unpack(&b32, "bytes32", output) if err != nil { t.Error("didn't expect error:", err) } @@ -697,7 +697,7 @@ func TestMarshalArrays(t *testing.T) { output[10] = 1 var shortAssignLong [32]byte - err = abi.unmarshal(&shortAssignLong, "bytes10", output) + err = abi.Unpack(&shortAssignLong, "bytes10", output) if err != nil { t.Error("didn't expect error:", err) } @@ -722,7 +722,7 @@ func TestUnmarshal(t *testing.T) { // marshal int var Int *big.Int - err = abi.unmarshal(&Int, "int", common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001")) + err = abi.Unpack(&Int, "int", common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001")) if err != nil { t.Error(err) } @@ -733,7 +733,7 @@ func TestUnmarshal(t *testing.T) { // marshal bool var Bool bool - err = abi.unmarshal(&Bool, "bool", common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001")) + err = abi.Unpack(&Bool, "bool", common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001")) if err != nil { t.Error(err) } @@ -750,7 +750,7 @@ func TestUnmarshal(t *testing.T) { buff.Write(bytesOut) var Bytes []byte - err = abi.unmarshal(&Bytes, "bytes", buff.Bytes()) + err = abi.Unpack(&Bytes, "bytes", buff.Bytes()) if err != nil { t.Error(err) } @@ -766,7 +766,7 @@ func TestUnmarshal(t *testing.T) { bytesOut = common.RightPadBytes([]byte("hello"), 64) buff.Write(bytesOut) - err = abi.unmarshal(&Bytes, "bytes", buff.Bytes()) + err = abi.Unpack(&Bytes, "bytes", buff.Bytes()) if err != nil { t.Error(err) } @@ -782,7 +782,7 @@ func TestUnmarshal(t *testing.T) { bytesOut = common.RightPadBytes([]byte("hello"), 63) buff.Write(bytesOut) - err = abi.unmarshal(&Bytes, "bytes", buff.Bytes()) + err = abi.Unpack(&Bytes, "bytes", buff.Bytes()) if err != nil { t.Error(err) } @@ -792,7 +792,7 @@ func TestUnmarshal(t *testing.T) { } // marshal dynamic bytes output empty - err = abi.unmarshal(&Bytes, "bytes", nil) + err = abi.Unpack(&Bytes, "bytes", nil) if err == nil { t.Error("expected error") } @@ -803,7 +803,7 @@ func TestUnmarshal(t *testing.T) { buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000005")) buff.Write(common.RightPadBytes([]byte("hello"), 32)) - err = abi.unmarshal(&Bytes, "bytes", buff.Bytes()) + err = abi.Unpack(&Bytes, "bytes", buff.Bytes()) if err != nil { t.Error(err) } @@ -817,7 +817,7 @@ func TestUnmarshal(t *testing.T) { buff.Write(common.RightPadBytes([]byte("hello"), 32)) var hash common.Hash - err = abi.unmarshal(&hash, "fixed", buff.Bytes()) + err = abi.Unpack(&hash, "fixed", buff.Bytes()) if err != nil { t.Error(err) } @@ -830,12 +830,12 @@ func TestUnmarshal(t *testing.T) { // marshal error buff.Reset() buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020")) - err = abi.unmarshal(&Bytes, "bytes", buff.Bytes()) + err = abi.Unpack(&Bytes, "bytes", buff.Bytes()) if err == nil { t.Error("expected error") } - err = abi.unmarshal(&Bytes, "multi", make([]byte, 64)) + err = abi.Unpack(&Bytes, "multi", make([]byte, 64)) if err == nil { t.Error("expected error") } @@ -850,7 +850,7 @@ func TestUnmarshal(t *testing.T) { buff.Write(bytesOut) var out []interface{} - err = abi.unmarshal(&out, "mixedBytes", buff.Bytes()) + err = abi.Unpack(&out, "mixedBytes", buff.Bytes()) if err != nil { t.Fatal("didn't expect error:", err) } diff --git a/accounts/abi/bind/backend.go b/accounts/abi/bind/backend.go new file mode 100644 index 000000000..fcd1c4d0a --- /dev/null +++ b/accounts/abi/bind/backend.go @@ -0,0 +1,247 @@ +// 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 ( + "encoding/json" + "fmt" + "math/big" + "sync" + "sync/atomic" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/rlp" + "github.com/ethereum/go-ethereum/rpc" +) + +// ContractCaller defines the methods needed to allow operating with contract on a read +// only basis. +type ContractCaller interface { + // ContractCall executes an Ethereum contract call with the specified data as + // the input. + ContractCall(contract common.Address, data []byte) ([]byte, error) +} + +// ContractTransactor defines the methods needed to allow operating with contract +// on a write only basis. Beside 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 { + // Nonce retrieves the current pending nonce associated with an account. + AccountNonce(account common.Address) (uint64, error) + + // GasPrice retrieves the currently suggested gas price to allow a timely execution + // of a transaction. + GasPrice() (*big.Int, error) + + // GasLimit tries to estimate the gas needed to execute a specific transaction. + GasLimit(sender, contract common.Address, value *big.Int, data []byte) (*big.Int, error) + + // SendTransaction injects the transaction into the pending pool for execution. + SendTransaction(*types.Transaction) error +} + +// ContractBackend defines the methods needed to allow operating with contract +// on a read-write basis. +type ContractBackend interface { + ContractCaller + ContractTransactor +} + +// nilBackend implements bind.ContractBackend, but panics on any method call. +// Its sole purpose is to support the binding tests to construct the generated +// wrappers without calling any methods on them. +type nilBackend struct{} + +func (*nilBackend) ContractCall(common.Address, []byte) ([]byte, error) { panic("not implemented") } +func (*nilBackend) SendTransaction(*types.Transaction) error { panic("not implemented") } +func (*nilBackend) AccountNonce(common.Address) (uint64, error) { panic("not implemented") } +func (*nilBackend) GasPrice() (*big.Int, error) { panic("not implemented") } +func (*nilBackend) GasLimit(common.Address, common.Address, *big.Int, []byte) (*big.Int, error) { + panic("not implemented") +} + +// Helper backend for internal tests. Will panic on any invocation! +var NilBackend = new(nilBackend) + +// rpcBackend implements bind.ContractBackend, and acts as the data provider to +// Ethereum contracts bound to Go structs. It uses an RPC connection to delegate +// all its functionality. +// +// Note: The current implementation is a blocking one. This should be replaced +// by a proper async version when a real RPC client is created. +type rpcBackend struct { + client rpc.Client // RPC client connection to interact with an API server + autoid uint32 // ID number to use for the next API request + lock sync.Mutex // Singleton access until we get to request multiplexing +} + +// NewRPCBackend creates a new binding backend to an RPC provider that can be +// used to interact with remote contracts. +func NewRPCBackend(client rpc.Client) ContractBackend { + return &rpcBackend{ + client: client, + } +} + +// request is a JSON RPC request package assembled internally from the client +// method calls. +type request struct { + JsonRpc string `json:"jsonrpc"` // Version of the JSON RPC protocol, always set to 2.0 + Id int `json:"id"` // Auto incrementing ID number for this request + Method string `json:"method"` // Remote procedure name to invoke on the server + Params []interface{} `json:"params"` // List of parameters to pass through (keep types simple) +} + +// response is a JSON RPC response package sent back from the API server. +type response struct { + JsonRpc string `json:"jsonrpc"` // Version of the JSON RPC protocol, always set to 2.0 + Id int `json:"id"` // Auto incrementing ID number for this request + Error json.RawMessage `json:"error"` // Any error returned by the remote side + Result json.RawMessage `json:"result"` // Whatever the remote side sends us in reply +} + +// request forwards an API request to the RPC server, and parses the response. +// +// This is currently painfully non-concurrent, but it will have to do until we +// find the time for niceties like this :P +func (backend *rpcBackend) request(method string, params []interface{}) (json.RawMessage, error) { + backend.lock.Lock() + defer backend.lock.Unlock() + + // Ugly hack to serialize an empty list properly + if params == nil { + params = []interface{}{} + } + // Assemble the request object + req := &request{ + JsonRpc: "2.0", + Id: int(atomic.AddUint32(&backend.autoid, 1)), + Method: method, + Params: params, + } + if err := backend.client.Send(req); err != nil { + return nil, err + } + res := new(response) + if err := backend.client.Recv(res); err != nil { + return nil, err + } + if len(res.Error) > 0 { + return nil, fmt.Errorf("remote error: %s", string(res.Error)) + } + return res.Result, nil +} + +// ContractCall implements ContractCaller.ContractCall, delegating the execution of +// a contract call to the remote node, returning the reply to for local processing. +func (b *rpcBackend) ContractCall(contract common.Address, data []byte) ([]byte, error) { + // Pack up the request into an RPC argument + args := struct { + To common.Address `json:"to"` + Data string `json:"data"` + }{ + To: contract, + Data: common.ToHex(data), + } + // Execute the RPC call and retrieve the response + res, err := b.request("eth_call", []interface{}{args, "pending"}) + if err != nil { + return nil, err + } + var hex string + if err := json.Unmarshal(res, &hex); err != nil { + return nil, err + } + // Convert the response back to a Go byte slice and return + return common.FromHex(hex), nil +} + +// AccountNonce implements ContractTransactor.AccountNonce, delegating the +// current account nonce retrieval to the remote node. +func (b *rpcBackend) AccountNonce(account common.Address) (uint64, error) { + res, err := b.request("eth_getTransactionCount", []interface{}{account.Hex(), "pending"}) + if err != nil { + return 0, err + } + var hex string + if err := json.Unmarshal(res, &hex); err != nil { + return 0, err + } + return new(big.Int).SetBytes(common.FromHex(hex)).Uint64(), nil +} + +// GasPrice implements ContractTransactor.GasPrice, delegating the gas price +// oracle request to the remote node. +func (b *rpcBackend) GasPrice() (*big.Int, error) { + res, err := b.request("eth_gasPrice", nil) + if err != nil { + return nil, err + } + var hex string + if err := json.Unmarshal(res, &hex); err != nil { + return nil, err + } + return new(big.Int).SetBytes(common.FromHex(hex)), nil +} + +// GasLimit implements ContractTransactor.GasLimit, delegating the gas estimation +// to the remote node. +func (b *rpcBackend) GasLimit(sender, contract common.Address, value *big.Int, data []byte) (*big.Int, error) { + // Pack up the request into an RPC argument + args := struct { + From common.Address `json:"from"` + To common.Address `json:"to"` + Value *rpc.HexNumber `json:"value"` + Data string `json:"data"` + }{ + From: sender, + To: contract, + Data: common.ToHex(data), + Value: rpc.NewHexNumber(value), + } + // Execute the RPC call and retrieve the response + res, err := b.request("eth_estimateGas", []interface{}{args}) + if err != nil { + return nil, err + } + var hex string + if err := json.Unmarshal(res, &hex); err != nil { + return nil, err + } + // Convert the response back to a Go byte slice and return + return new(big.Int).SetBytes(common.FromHex(hex)), nil +} + +// Transact implements ContractTransactor.SendTransaction, delegating the raw +// transaction injection to the remote node. +func (b *rpcBackend) SendTransaction(tx *types.Transaction) error { + data, err := rlp.EncodeToBytes(tx) + if err != nil { + return err + } + res, err := b.request("eth_sendRawTransaction", []interface{}{common.ToHex(data)}) + if err != nil { + return err + } + var hex string + if err := json.Unmarshal(res, &hex); err != nil { + return err + } + return nil +} diff --git a/accounts/abi/bind/base.go b/accounts/abi/bind/base.go new file mode 100644 index 000000000..75e3c1d2d --- /dev/null +++ b/accounts/abi/bind/base.go @@ -0,0 +1,130 @@ +// 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 ( + "errors" + "fmt" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// 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) + +// AuthOpts is the authorization data required to create a valid Ethereum transaction. +type AuthOpts struct { + Account 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 along the transaction (nil = 0 = no funds) + GasPrice *big.Int // Gas price to use for the transaction execution (nil = gas price oracle) + GasLimit *big.Int // Gas limit to set for the transaction execution (nil = estimate + 10%) +} + +// 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 +} + +// 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) *BoundContract { + return &BoundContract{ + address: address, + abi: abi, + caller: caller, + transactor: transactor, + } +} + +// 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(result interface{}, method string, params ...interface{}) error { + input, err := c.abi.Pack(method, params...) + if err != nil { + return err + } + output, err := c.caller.ContractCall(c.address, input) + if err != nil { + return err + } + return c.abi.Unpack(result, method, output) +} + +// Transact invokes the (paid) contract method with params as input values and +// value as the fund transfer to the contract. +func (c *BoundContract) Transact(opts *AuthOpts, method string, params ...interface{}) (*types.Transaction, error) { + input, err := c.abi.Pack(method, params...) + if err != nil { + return nil, err + } + // Ensure a valid value field and resolve the account nonce + value := opts.Value + if value == nil { + value = new(big.Int) + } + nonce := uint64(0) + if opts.Nonce == nil { + nonce, err = c.transactor.AccountNonce(opts.Account) + if err != nil { + return nil, fmt.Errorf("failed to retrieve account nonce: %v", err) + } + } else { + nonce = opts.Nonce.Uint64() + } + // Figure out the gas allowance and gas price values + gasPrice := opts.GasPrice + if gasPrice == nil { + gasPrice, err = c.transactor.GasPrice() + if err != nil { + return nil, fmt.Errorf("failed to suggest gas price: %v", err) + } + } + gasLimit := opts.GasLimit + if gasLimit == nil { + gasLimit, err = c.transactor.GasLimit(opts.Account, c.address, value, input) + if err != nil { + return nil, fmt.Errorf("failed to exstimate gas needed: %v", err) + } + } + // Create the transaction, sign it and schedule it for execution + rawTx := types.NewTransaction(nonce, c.address, value, gasLimit, gasPrice, input) + if opts.Signer == nil { + return nil, errors.New("no signer to authorize the transaction with") + } + signedTx, err := opts.Signer(opts.Account, rawTx) + if err != nil { + return nil, err + } + if err := c.transactor.SendTransaction(signedTx); err != nil { + return nil, err + } + return signedTx, nil +} diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go new file mode 100644 index 000000000..bef75a158 --- /dev/null +++ b/accounts/abi/bind/bind.go @@ -0,0 +1,317 @@ +// 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. +package bind + +import ( + "bytes" + "fmt" + "sort" + "strings" + + "github.com/ethereum/go-ethereum/accounts/abi" + "golang.org/x/tools/imports" +) + +// Bind generates a Go wrapper around a contract ABI. This wrapper isn't meant +// to be used as is in client code, but rather as an intermediate struct which +// enforces compile time type safety and naming convention opposed to having to +// manually maintain hard coded strings that break on runtime. +func Bind(jsonABI string, pkg string, kind string) (string, error) { + // Parse the actual ABI to generate the binding for + abi, err := abi.JSON(strings.NewReader(jsonABI)) + if err != nil { + return "", err + } + // Generate the contract type, fields and methods + code := new(bytes.Buffer) + kind = strings.ToUpper(kind[:1]) + kind[1:] + fmt.Fprintf(code, "%s\n", bindContract(kind, jsonABI)) + + methods := make([]string, 0, len(abi.Methods)) + for name, _ := range abi.Methods { + methods = append(methods, name) + } + sort.Strings(methods) + + for _, method := range methods { + fmt.Fprintf(code, "%s\n", bindMethod(kind, abi.Methods[method])) + } + // Format the code with goimports and return + buffer := new(bytes.Buffer) + + fmt.Fprintf(buffer, "package %s\n\n", pkg) + fmt.Fprintf(buffer, "%s\n\n", string(code.Bytes())) + + blob, err := imports.Process("", buffer.Bytes(), nil) + if err != nil { + return "", err + } + return string(blob), nil +} + +// bindContract generates the basic wrapper code for interacting with an Ethereum +// contract via the abi package. All contract methods will call into the generic +// ones generated here. +func bindContract(kind string, abi string) string { + code := "" + + // Generate the hard coded ABI used for Ethereum interaction + code += fmt.Sprintf("// Ethereum ABI used to generate the binding from.\nconst %sABI = `%s`\n\n", kind, strings.TrimSpace(abi)) + + // Generate the Go struct with all the maintenance fields + code += fmt.Sprintf("// %s is an auto generated Go binding around an Ethereum contract.\n", kind) + code += fmt.Sprintf("type %s struct {\n", kind) + code += fmt.Sprintf(" %sCaller // Read-only binding to the contract\n", kind) + code += fmt.Sprintf(" %sTransactor // Write-only binding to the contract\n", kind) + code += fmt.Sprintf("}\n\n") + + code += fmt.Sprintf("// %sCaller is an auto generated read-only Go binding around an Ethereum contract.\n", kind) + code += fmt.Sprintf("type %sCaller struct {\n", kind) + code += fmt.Sprintf(" common *common%s // Contract binding common to callers and transactors\n", kind) + code += fmt.Sprintf("}\n\n") + + code += fmt.Sprintf("// %sTransactor is an auto generated write-only Go binding around an Ethereum contract.\n", kind) + code += fmt.Sprintf("type %sTransactor struct {\n", kind) + code += fmt.Sprintf(" common *common%s // Contract binding common to callers and transactors\n", kind) + code += fmt.Sprintf("}\n\n") + + code += fmt.Sprintf("// common%s is an auto generated Go binding around an Ethereum contract.\n", kind) + code += fmt.Sprintf("type common%s struct {\n", kind) + code += fmt.Sprintf(" contract *bind.BoundContract // Generic contract wrapper for the low level calls\n") + code += fmt.Sprintf("}\n\n") + + // Generate the constructor to create a bound contract + code += fmt.Sprintf("// New%s creates a new instance of %s, bound to a specific deployed contract.\n", kind, kind) + code += fmt.Sprintf("func New%s(address common.Address, backend bind.ContractBackend) (*%s, error) {\n", kind, kind) + code += fmt.Sprintf(" common, err := newCommon%s(address, backend.(bind.ContractCaller), backend.(bind.ContractTransactor))\n", kind) + code += fmt.Sprintf(" if err != nil {\n") + code += fmt.Sprintf(" return nil, err\n") + code += fmt.Sprintf(" }\n") + code += fmt.Sprintf(" return &%s{%sCaller: %sCaller{common: common}, %sTransactor: %sTransactor{common: common}}, nil\n", kind, kind, kind, kind, kind) + code += fmt.Sprintf("}\n\n") + + code += fmt.Sprintf("// New%sCaller creates a new read-only instance of %s, bound to a specific deployed contract.\n", kind, kind) + code += fmt.Sprintf("func New%sCaller(address common.Address, caller bind.ContractCaller) (*%sCaller, error) {\n", kind, kind) + code += fmt.Sprintf(" common, err := newCommon%s(address, caller, nil)\n", kind) + code += fmt.Sprintf(" if err != nil {\n") + code += fmt.Sprintf(" return nil, err\n") + code += fmt.Sprintf(" }\n") + code += fmt.Sprintf(" return &%sCaller{common: common}, nil\n", kind) + code += fmt.Sprintf("}\n\n") + + code += fmt.Sprintf("// New%sTransactor creates a new write-only instance of %s, bound to a specific deployed contract.\n", kind, kind) + code += fmt.Sprintf("func New%sTransactor(address common.Address, transactor bind.ContractTransactor) (*%sTransactor, error) {\n", kind, kind) + code += fmt.Sprintf(" common, err := newCommon%s(address, nil, transactor)\n", kind) + code += fmt.Sprintf(" if err != nil {\n") + code += fmt.Sprintf(" return nil, err\n") + code += fmt.Sprintf(" }\n") + code += fmt.Sprintf(" return &%sTransactor{common: common}, nil\n", kind) + code += fmt.Sprintf("}\n\n") + + code += fmt.Sprintf("// newCommon%s creates an internal instance of %s, bound to a specific deployed contract.\n", kind, kind) + code += fmt.Sprintf("func newCommon%s(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor) (*common%s, error) {\n", kind, kind) + code += fmt.Sprintf(" parsed, err := abi.JSON(strings.NewReader(%sABI))\n", kind) + code += fmt.Sprintf(" if err != nil {\n") + code += fmt.Sprintf(" return nil, err\n") + code += fmt.Sprintf(" }\n") + code += fmt.Sprintf(" return &common%s{\n", kind) + code += fmt.Sprintf(" contract: bind.NewBoundContract(address, parsed, caller, transactor),\n") + code += fmt.Sprintf(" }, nil\n") + code += fmt.Sprintf("}") + + return code +} + +// bindMethod +func bindMethod(kind string, method abi.Method) string { + var ( + name = strings.ToUpper(method.Name[:1]) + method.Name[1:] + prologue = new(bytes.Buffer) + ) + // Generate the argument and return list for the function + args := make([]string, 0, len(method.Inputs)) + for i, arg := range method.Inputs { + param := arg.Name + if param == "" { + param = fmt.Sprintf("arg%d", i) + } + args = append(args, fmt.Sprintf("%s %s", param, bindType(arg.Type))) + } + returns, _ := bindReturn(prologue, name, method.Outputs) + + // Generate the docs to help with coding against the binding + callTypeDoc := "free data retrieval call" + if !method.Const { + callTypeDoc = "paid mutator transaction" + } + docs := fmt.Sprintf("// %s is a %s binding the contract method 0x%x.\n", name, callTypeDoc, method.Id()) + docs += fmt.Sprintf("// \n") + docs += fmt.Sprintf("// Solidity: %s", strings.TrimPrefix(method.String(), "function ")) + + // Generate the method itself for both the read/write version and the combo too + code := fmt.Sprintf("%s\n", prologue) + if method.Const { + code += fmt.Sprintf("%s\nfunc (_%s *%sCaller) %s(%s) (%s) {\n%s\n}\n", docs, kind, kind, name, strings.Join(args, ","), strings.Join(returns, ","), bindCallBody(kind, method.Name, args, returns)) + } else { + args = append([]string{"auth *bind.AuthOpts"}, args...) + code += fmt.Sprintf("%s\nfunc (_%s *%sTransactor) %s(%s) (*types.Transaction, error) {\n%s\n}\n", docs, kind, kind, name, strings.Join(args, ","), bindTransactionBody(kind, method.Name, args)) + } + return code +} + +// bindType converts a Solidity type to a Go one. 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. *big.Int). +func bindType(kind abi.Type) string { + stringKind := kind.String() + + switch { + case stringKind == "address": + return "common.Address" + + case stringKind == "hash": + return "common.Hash" + + case strings.HasPrefix(stringKind, "bytes"): + if stringKind == "bytes" { + return "[]byte" + } + return fmt.Sprintf("[%s]byte", stringKind[5:]) + + case strings.HasPrefix(stringKind, "int"): + switch stringKind[:3] { + case "8", "16", "32", "64": + return stringKind + } + return "*big.Int" + + case strings.HasPrefix(stringKind, "uint"): + switch stringKind[:4] { + case "8", "16", "32", "64": + return stringKind + } + return "*big.Int" + + default: + return stringKind + } +} + +// bindReturn creates the list of return parameters for a method invocation. If +// all the fields of the return type are named, and there is more than one value +// being returned, the returns are wrapped in a result struct. +func bindReturn(prologue *bytes.Buffer, method string, outputs []abi.Argument) ([]string, string) { + // Generate the anonymous return list for when a struct is not needed/possible + var ( + returns = make([]string, 0, len(outputs)+1) + anonymous = false + ) + for _, ret := range outputs { + returns = append(returns, bindType(ret.Type)) + if ret.Name == "" { + anonymous = true + } + } + if anonymous || len(returns) < 2 { + returns = append(returns, "error") + return returns, "" + } + // If the returns are named and numerous, wrap in a result struct + wrapper, impl := bindReturnStruct(method, outputs) + prologue.WriteString(impl + "\n") + return []string{"*" + wrapper, "error"}, wrapper +} + +// bindReturnStruct creates a Go structure with the specified fields to be used +// as the return type from a method call. +func bindReturnStruct(method string, returns []abi.Argument) (string, string) { + fields := make([]string, 0, len(returns)) + for _, ret := range returns { + fields = append(fields, fmt.Sprintf("%s %s", strings.ToUpper(ret.Name[:1])+ret.Name[1:], bindType(ret.Type))) + } + kind := fmt.Sprintf("%sResult", method) + docs := fmt.Sprintf("// %s is the result of the %s invocation.", kind, method) + + return kind, fmt.Sprintf("%s\ntype %s struct {\n%s\n}", docs, kind, strings.Join(fields, "\n")) +} + +// bindCallBody creates the Go code to declare a batch of return values, invoke +// an Ethereum method call with the requested parameters, parse the binary output +// into the return values and return them. +func bindCallBody(kind string, method string, params []string, returns []string) string { + body := "" + + // Allocate memory for each of the return values + rets := make([]string, 0, len(returns)-1) + if len(returns) > 1 { + body += "var (" + for i, kind := range returns[:len(returns)-1] { // Omit the final error + name := fmt.Sprintf("ret%d", i) + + rets = append(rets, name) + body += fmt.Sprintf("%s = new(%s)\n", name, strings.TrimPrefix(kind, "*")) + } + body += ")\n" + } + // Assemble a single collector variable for the result ABI initialization + result := strings.Join(rets, ",") + if len(returns) > 2 { + result = "[]interface{}{" + result + "}" + } + // Extract the parameter list into a flat variable name list + inputs := make([]string, len(params)) + for i, param := range params { + inputs[i] = strings.Split(param, " ")[0] + } + input := "" + if len(inputs) > 0 { + input = "," + strings.Join(inputs, ",") + } + // Request executing the contract call and return the results with the errors + body += fmt.Sprintf("err := _%s.common.contract.Call(%s, \"%s\" %s)\n", kind, result, method, input) + + outs := make([]string, 0, len(returns)) + for i, ret := range returns[:len(returns)-1] { // Handle th final error separately + if strings.HasPrefix(ret, "*") { + outs = append(outs, rets[i]) + } else { + outs = append(outs, "*"+rets[i]) + } + } + outs = append(outs, "err") + + body += fmt.Sprintf("return %s", strings.Join(outs, ",")) + + return body +} + +// bindTransactionBody creates the Go code to invoke an Ethereum transaction call +// with the requested parameters, and return the assembled transaction object. +func bindTransactionBody(kind string, method string, params []string) string { + // Extract the parameter list into a flat variable name list + inputs := make([]string, len(params)-1) // Omit the auth options + for i, param := range params[1:] { + inputs[i] = strings.Split(param, " ")[0] + } + input := "" + if len(inputs) > 0 { + input = "," + strings.Join(inputs, ",") + } + // Request executing the contract call and return the results with the errors + return fmt.Sprintf("return _%s.common.contract.Transact(auth, \"%s\" %s)", kind, method, input) +} diff --git a/accounts/abi/bind/bind_test.go b/accounts/abi/bind/bind_test.go new file mode 100644 index 000000000..f13f7829e --- /dev/null +++ b/accounts/abi/bind/bind_test.go @@ -0,0 +1,140 @@ +// Copyright 2016 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package bind + +import ( + "fmt" + "io/ioutil" + "os" + "os/exec" + "path/filepath" + "runtime" + "strings" + "testing" + + "github.com/ethereum/go-ethereum/common" + "golang.org/x/tools/imports" +) + +var bindTests = []struct { + name string + contract string + bytecode string + abi string + tester string +}{ + // Test that the binding is available in combined and separate forms too + { + `Empty`, + `contract NilContract {}`, + `606060405260068060106000396000f3606060405200`, + `[]`, + `if b, err := NewEmpty(common.Address{}, bind.NilBackend); b == nil || err != nil { + t.Fatalf("combined binding (%v) nil or error (%v) not nil", b, nil) + } + if b, err := NewEmptyCaller(common.Address{}, bind.NilBackend); b == nil || err != nil { + t.Fatalf("caller binding (%v) nil or error (%v) not nil", b, nil) + } + if b, err := NewEmptyTransactor(common.Address{}, bind.NilBackend); b == nil || err != nil { + t.Fatalf("transactor binding (%v) nil or error (%v) not nil", b, nil) + }`, + }, + // Test that all the official sample contracts bind correctly + { + `Token`, + `https://ethereum.org/token`, + `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`, + `[{"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"}]`, + `if b, err := NewToken(common.Address{}, bind.NilBackend); b == nil || err != nil { + t.Fatalf("binding (%v) nil or error (%v) not nil", b, nil) + }`, + }, + { + `Crowdsale`, + `https://ethereum.org/crowdsale`, + `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`, + `[{"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"}]`, + `if b, err := NewCrowdsale(common.Address{}, bind.NilBackend); b == nil || err != nil { + t.Fatalf("binding (%v) nil or error (%v) not nil", b, nil) + }`, + }, + { + `DAO`, + `https://ethereum.org/dao`, + `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`, + `[{"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"}]`, + `if b, err := NewDAO(common.Address{}, bind.NilBackend); b == nil || err != nil { + t.Fatalf("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 TestBindings(t *testing.T) { + // Skip the test if no Go command can be found + gocmd := runtime.GOROOT() + "/bin/go" + if !common.FileExist(gocmd) { + t.Skip("go sdk not found for testing") + } + // Skip the test if the go-ethereum sources are symlinked (https://github.com/golang/go/issues/14845) + linkTestCode := fmt.Sprintf("package linktest\nfunc CheckSymlinks(){\nfmt.Println(bind.NilBackend)\n}") + linkTestDeps, err := imports.Process("", []byte(linkTestCode), nil) + if err != nil { + t.Fatalf("failed check for goimports symlink bug: %v", err) + } + if !strings.Contains(string(linkTestDeps), "go-ethereum") { + t.Skip("symlinked environment doesn't support bind (https://github.com/golang/go/issues/14845)") + } + // All is well, run the tests + for i, tt := range bindTests { + // Create a temporary workspace for this test + ws, err := ioutil.TempDir("", "") + if err != nil { + t.Fatalf("test %d: failed to create temporary workspace: %v", i, err) + } + defer os.RemoveAll(ws) + + // Generate the binding and create a Go package in the workspace + bind, err := Bind(tt.abi, "bindtest", tt.name) + if err != nil { + t.Fatalf("test %d: failed to generate binding: %v", i, err) + } + pkg := filepath.Join(ws, "bindtest") + if err := os.MkdirAll(pkg, 0700); err != nil { + t.Fatalf("test %d: failed to create package: %v", i, err) + } + if err := ioutil.WriteFile(filepath.Join(pkg, "main.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\nimport \"testing\"\nfunc TestBinding%d(t *testing.T){\n%s\n}", i, tt.tester) + blob, err := imports.Process("", []byte(code), nil) + if err != nil { + t.Fatalf("test %d: failed to generate tests: %v", i, err) + } + if err := ioutil.WriteFile(filepath.Join(pkg, "main_test.go"), blob, 0600); err != nil { + t.Fatalf("test %d: failed to write tests: %v", i, err) + } + // Test the entire package and report any failures + cmd := exec.Command(gocmd, "test", "-v") + cmd.Dir = pkg + if out, err := cmd.CombinedOutput(); err != nil { + t.Fatalf("test %d: failed to run binding test: %v\n%s", i, err, out) + } + } +} -- cgit v1.2.3 From 86cfc22c79594bd0d9625650dcbfb60c3e6ba9fe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?P=C3=A9ter=20Szil=C3=A1gyi?= Date: Thu, 17 Mar 2016 19:27:37 +0200 Subject: accounts/abi/bind: constructor, auth utils and various backends --- accounts/abi/abi.go | 46 +++++--- accounts/abi/bind/auth.go | 53 +++++++++ accounts/abi/bind/backend.go | 196 +------------------------------ accounts/abi/bind/backends/nil.go | 46 ++++++++ accounts/abi/bind/backends/remote.go | 202 ++++++++++++++++++++++++++++++++ accounts/abi/bind/backends/simulated.go | 184 +++++++++++++++++++++++++++++ accounts/abi/bind/base.go | 66 +++++++++-- accounts/abi/bind/bind.go | 177 ++++++++++++++++++++++------ accounts/abi/bind/bind_test.go | 16 +-- 9 files changed, 723 insertions(+), 263 deletions(-) create mode 100644 accounts/abi/bind/auth.go create mode 100644 accounts/abi/bind/backends/nil.go create mode 100644 accounts/abi/bind/backends/remote.go create mode 100644 accounts/abi/bind/backends/simulated.go (limited to 'accounts/abi') diff --git a/accounts/abi/abi.go b/accounts/abi/abi.go index 029d1b102..91f9700d9 100644 --- a/accounts/abi/abi.go +++ b/accounts/abi/abi.go @@ -30,8 +30,9 @@ import ( // invokable methods. It will allow you to type check function calls and // packs data accordingly. type ABI struct { - Methods map[string]Method - Events map[string]Event + Constructor Method + Methods map[string]Method + Events map[string]Event } // JSON returns a parsed ABI interface and error if it failed. @@ -48,9 +49,7 @@ func JSON(reader io.Reader) (ABI, error) { // tests, tests whether the given input would result in a successful // call. Checks argument list count and matches input to `input`. -func (abi ABI) pack(name string, args ...interface{}) ([]byte, error) { - method := abi.Methods[name] - +func (abi ABI) pack(method Method, args ...interface{}) ([]byte, error) { // variable input is the output appended at the end of packed // output. This is used for strings and bytes types input. var variableInput []byte @@ -61,7 +60,7 @@ func (abi ABI) pack(name string, args ...interface{}) ([]byte, error) { // pack the input packed, err := input.Type.pack(a) if err != nil { - return nil, fmt.Errorf("`%s` %v", name, err) + return nil, fmt.Errorf("`%s` %v", method.Name, err) } // check for a string or bytes input type @@ -91,26 +90,31 @@ func (abi ABI) pack(name string, args ...interface{}) ([]byte, error) { // 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) { - method, exist := abi.Methods[name] - if !exist { - return nil, fmt.Errorf("method '%s' not found", name) - } + // Fetch the ABI of the requested method + var method Method - // start with argument count match + if name == "" { + method = abi.Constructor + } else { + m, exist := abi.Methods[name] + if !exist { + return nil, fmt.Errorf("method '%s' not found", name) + } + method = m + } + // Make sure arguments match up and pack them if len(args) != len(method.Inputs) { return nil, fmt.Errorf("argument count mismatch: %d for %d", len(args), len(method.Inputs)) } - - arguments, err := abi.pack(name, args...) + arguments, err := abi.pack(method, args...) if err != nil { return nil, err } - - // Set function id - packed := abi.Methods[name].Id() - packed = append(packed, arguments...) - - return packed, nil + // Pack up the method ID too if not a constructor and return + if name == "" { + return arguments, nil + } + return append(method.Id(), arguments...), nil } // toGoType parses the input and casts it to the proper type defined by the ABI @@ -283,6 +287,10 @@ func (abi *ABI) UnmarshalJSON(data []byte) error { abi.Events = make(map[string]Event) for _, field := range fields { switch field.Type { + case "constructor": + abi.Constructor = Method{ + Inputs: field.Inputs, + } // empty defaults to function according to the abi spec case "function", "": abi.Methods[field.Name] = Method{ diff --git a/accounts/abi/bind/auth.go b/accounts/abi/bind/auth.go new file mode 100644 index 000000000..e0491497c --- /dev/null +++ b/accounts/abi/bind/auth.go @@ -0,0 +1,53 @@ +// 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 ( + "errors" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" +) + +// NewTransactor is a utility method to easily create a transaction signer from +// an encrypted json key file and the associated passphrase. +func NewTransactor(keyjson string, passphrase string) (*TransactOpts, error) { + key, err := crypto.DecryptKey([]byte(keyjson), passphrase) + if err != nil { + return nil, err + } + return NewKeyedTransactor(key), nil +} + +// NewKeyedTransactor is a utility method to easily create a transaction signer +// from a plain go-ethereum crypto key. +func NewKeyedTransactor(key *crypto.Key) *TransactOpts { + return &TransactOpts{ + Account: key.Address, + Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) { + if address != key.Address { + return nil, errors.New("not authorized to sign this account") + } + signature, err := crypto.Sign(tx.SigHash().Bytes(), key.PrivateKey) + if err != nil { + return nil, err + } + return tx.WithSignature(signature) + }, + } +} diff --git a/accounts/abi/bind/backend.go b/accounts/abi/bind/backend.go index fcd1c4d0a..596e97f1d 100644 --- a/accounts/abi/bind/backend.go +++ b/accounts/abi/bind/backend.go @@ -17,24 +17,19 @@ package bind import ( - "encoding/json" - "fmt" "math/big" - "sync" - "sync/atomic" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/rlp" - "github.com/ethereum/go-ethereum/rpc" ) // ContractCaller defines the methods needed to allow operating with contract on a read // only basis. type ContractCaller interface { // ContractCall executes an Ethereum contract call with the specified data as - // the input. - ContractCall(contract common.Address, data []byte) ([]byte, error) + // the input. The pending flag requests execution against the pending block, not + // the stable head of the chain. + ContractCall(contract common.Address, data []byte, pending bool) ([]byte, error) } // ContractTransactor defines the methods needed to allow operating with contract @@ -50,7 +45,7 @@ type ContractTransactor interface { GasPrice() (*big.Int, error) // GasLimit tries to estimate the gas needed to execute a specific transaction. - GasLimit(sender, contract common.Address, value *big.Int, data []byte) (*big.Int, error) + GasLimit(sender common.Address, contract *common.Address, value *big.Int, data []byte) (*big.Int, error) // SendTransaction injects the transaction into the pending pool for execution. SendTransaction(*types.Transaction) error @@ -62,186 +57,3 @@ type ContractBackend interface { ContractCaller ContractTransactor } - -// nilBackend implements bind.ContractBackend, but panics on any method call. -// Its sole purpose is to support the binding tests to construct the generated -// wrappers without calling any methods on them. -type nilBackend struct{} - -func (*nilBackend) ContractCall(common.Address, []byte) ([]byte, error) { panic("not implemented") } -func (*nilBackend) SendTransaction(*types.Transaction) error { panic("not implemented") } -func (*nilBackend) AccountNonce(common.Address) (uint64, error) { panic("not implemented") } -func (*nilBackend) GasPrice() (*big.Int, error) { panic("not implemented") } -func (*nilBackend) GasLimit(common.Address, common.Address, *big.Int, []byte) (*big.Int, error) { - panic("not implemented") -} - -// Helper backend for internal tests. Will panic on any invocation! -var NilBackend = new(nilBackend) - -// rpcBackend implements bind.ContractBackend, and acts as the data provider to -// Ethereum contracts bound to Go structs. It uses an RPC connection to delegate -// all its functionality. -// -// Note: The current implementation is a blocking one. This should be replaced -// by a proper async version when a real RPC client is created. -type rpcBackend struct { - client rpc.Client // RPC client connection to interact with an API server - autoid uint32 // ID number to use for the next API request - lock sync.Mutex // Singleton access until we get to request multiplexing -} - -// NewRPCBackend creates a new binding backend to an RPC provider that can be -// used to interact with remote contracts. -func NewRPCBackend(client rpc.Client) ContractBackend { - return &rpcBackend{ - client: client, - } -} - -// request is a JSON RPC request package assembled internally from the client -// method calls. -type request struct { - JsonRpc string `json:"jsonrpc"` // Version of the JSON RPC protocol, always set to 2.0 - Id int `json:"id"` // Auto incrementing ID number for this request - Method string `json:"method"` // Remote procedure name to invoke on the server - Params []interface{} `json:"params"` // List of parameters to pass through (keep types simple) -} - -// response is a JSON RPC response package sent back from the API server. -type response struct { - JsonRpc string `json:"jsonrpc"` // Version of the JSON RPC protocol, always set to 2.0 - Id int `json:"id"` // Auto incrementing ID number for this request - Error json.RawMessage `json:"error"` // Any error returned by the remote side - Result json.RawMessage `json:"result"` // Whatever the remote side sends us in reply -} - -// request forwards an API request to the RPC server, and parses the response. -// -// This is currently painfully non-concurrent, but it will have to do until we -// find the time for niceties like this :P -func (backend *rpcBackend) request(method string, params []interface{}) (json.RawMessage, error) { - backend.lock.Lock() - defer backend.lock.Unlock() - - // Ugly hack to serialize an empty list properly - if params == nil { - params = []interface{}{} - } - // Assemble the request object - req := &request{ - JsonRpc: "2.0", - Id: int(atomic.AddUint32(&backend.autoid, 1)), - Method: method, - Params: params, - } - if err := backend.client.Send(req); err != nil { - return nil, err - } - res := new(response) - if err := backend.client.Recv(res); err != nil { - return nil, err - } - if len(res.Error) > 0 { - return nil, fmt.Errorf("remote error: %s", string(res.Error)) - } - return res.Result, nil -} - -// ContractCall implements ContractCaller.ContractCall, delegating the execution of -// a contract call to the remote node, returning the reply to for local processing. -func (b *rpcBackend) ContractCall(contract common.Address, data []byte) ([]byte, error) { - // Pack up the request into an RPC argument - args := struct { - To common.Address `json:"to"` - Data string `json:"data"` - }{ - To: contract, - Data: common.ToHex(data), - } - // Execute the RPC call and retrieve the response - res, err := b.request("eth_call", []interface{}{args, "pending"}) - if err != nil { - return nil, err - } - var hex string - if err := json.Unmarshal(res, &hex); err != nil { - return nil, err - } - // Convert the response back to a Go byte slice and return - return common.FromHex(hex), nil -} - -// AccountNonce implements ContractTransactor.AccountNonce, delegating the -// current account nonce retrieval to the remote node. -func (b *rpcBackend) AccountNonce(account common.Address) (uint64, error) { - res, err := b.request("eth_getTransactionCount", []interface{}{account.Hex(), "pending"}) - if err != nil { - return 0, err - } - var hex string - if err := json.Unmarshal(res, &hex); err != nil { - return 0, err - } - return new(big.Int).SetBytes(common.FromHex(hex)).Uint64(), nil -} - -// GasPrice implements ContractTransactor.GasPrice, delegating the gas price -// oracle request to the remote node. -func (b *rpcBackend) GasPrice() (*big.Int, error) { - res, err := b.request("eth_gasPrice", nil) - if err != nil { - return nil, err - } - var hex string - if err := json.Unmarshal(res, &hex); err != nil { - return nil, err - } - return new(big.Int).SetBytes(common.FromHex(hex)), nil -} - -// GasLimit implements ContractTransactor.GasLimit, delegating the gas estimation -// to the remote node. -func (b *rpcBackend) GasLimit(sender, contract common.Address, value *big.Int, data []byte) (*big.Int, error) { - // Pack up the request into an RPC argument - args := struct { - From common.Address `json:"from"` - To common.Address `json:"to"` - Value *rpc.HexNumber `json:"value"` - Data string `json:"data"` - }{ - From: sender, - To: contract, - Data: common.ToHex(data), - Value: rpc.NewHexNumber(value), - } - // Execute the RPC call and retrieve the response - res, err := b.request("eth_estimateGas", []interface{}{args}) - if err != nil { - return nil, err - } - var hex string - if err := json.Unmarshal(res, &hex); err != nil { - return nil, err - } - // Convert the response back to a Go byte slice and return - return new(big.Int).SetBytes(common.FromHex(hex)), nil -} - -// Transact implements ContractTransactor.SendTransaction, delegating the raw -// transaction injection to the remote node. -func (b *rpcBackend) SendTransaction(tx *types.Transaction) error { - data, err := rlp.EncodeToBytes(tx) - if err != nil { - return err - } - res, err := b.request("eth_sendRawTransaction", []interface{}{common.ToHex(data)}) - if err != nil { - return err - } - var hex string - if err := json.Unmarshal(res, &hex); err != nil { - return err - } - return nil -} diff --git a/accounts/abi/bind/backends/nil.go b/accounts/abi/bind/backends/nil.go new file mode 100644 index 000000000..8b1f9d63e --- /dev/null +++ b/accounts/abi/bind/backends/nil.go @@ -0,0 +1,46 @@ +// 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 backends + +import ( + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// nilBackend implements bind.ContractBackend, but panics on any method call. +// Its sole purpose is to support the binding tests to construct the generated +// wrappers without calling any methods on them. +type nilBackend struct{} + +func (*nilBackend) ContractCall(common.Address, []byte, bool) ([]byte, error) { + panic("not implemented") +} +func (*nilBackend) GasLimit(common.Address, *common.Address, *big.Int, []byte) (*big.Int, error) { + panic("not implemented") +} +func (*nilBackend) GasPrice() (*big.Int, error) { panic("not implemented") } +func (*nilBackend) AccountNonce(common.Address) (uint64, error) { panic("not implemented") } +func (*nilBackend) SendTransaction(*types.Transaction) error { panic("not implemented") } + +// NewNilBackend creates a new binding backend that can be used for instantiation +// but will panic on any invocation. Its sole purpose is to help testing. +func NewNilBackend() bind.ContractBackend { + return new(nilBackend) +} diff --git a/accounts/abi/bind/backends/remote.go b/accounts/abi/bind/backends/remote.go new file mode 100644 index 000000000..7177809bb --- /dev/null +++ b/accounts/abi/bind/backends/remote.go @@ -0,0 +1,202 @@ +// 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 backends + +import ( + "encoding/json" + "fmt" + "math/big" + "sync" + "sync/atomic" + + "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/rlp" + "github.com/ethereum/go-ethereum/rpc" +) + +// rpcBackend implements bind.ContractBackend, and acts as the data provider to +// Ethereum contracts bound to Go structs. It uses an RPC connection to delegate +// all its functionality. +// +// Note: The current implementation is a blocking one. This should be replaced +// by a proper async version when a real RPC client is created. +type rpcBackend struct { + client rpc.Client // RPC client connection to interact with an API server + autoid uint32 // ID number to use for the next API request + lock sync.Mutex // Singleton access until we get to request multiplexing +} + +// NewRPCBackend creates a new binding backend to an RPC provider that can be +// used to interact with remote contracts. +func NewRPCBackend(client rpc.Client) bind.ContractBackend { + return &rpcBackend{ + client: client, + } +} + +// request is a JSON RPC request package assembled internally from the client +// method calls. +type request struct { + JsonRpc string `json:"jsonrpc"` // Version of the JSON RPC protocol, always set to 2.0 + Id int `json:"id"` // Auto incrementing ID number for this request + Method string `json:"method"` // Remote procedure name to invoke on the server + Params []interface{} `json:"params"` // List of parameters to pass through (keep types simple) +} + +// response is a JSON RPC response package sent back from the API server. +type response struct { + JsonRpc string `json:"jsonrpc"` // Version of the JSON RPC protocol, always set to 2.0 + Id int `json:"id"` // Auto incrementing ID number for this request + Error json.RawMessage `json:"error"` // Any error returned by the remote side + Result json.RawMessage `json:"result"` // Whatever the remote side sends us in reply +} + +// request forwards an API request to the RPC server, and parses the response. +// +// This is currently painfully non-concurrent, but it will have to do until we +// find the time for niceties like this :P +func (backend *rpcBackend) request(method string, params []interface{}) (json.RawMessage, error) { + backend.lock.Lock() + defer backend.lock.Unlock() + + // Ugly hack to serialize an empty list properly + if params == nil { + params = []interface{}{} + } + // Assemble the request object + req := &request{ + JsonRpc: "2.0", + Id: int(atomic.AddUint32(&backend.autoid, 1)), + Method: method, + Params: params, + } + if err := backend.client.Send(req); err != nil { + return nil, err + } + res := new(response) + if err := backend.client.Recv(res); err != nil { + return nil, err + } + if len(res.Error) > 0 { + return nil, fmt.Errorf("remote error: %s", string(res.Error)) + } + return res.Result, nil +} + +// ContractCall implements ContractCaller.ContractCall, delegating the execution of +// a contract call to the remote node, returning the reply to for local processing. +func (b *rpcBackend) ContractCall(contract common.Address, data []byte, pending bool) ([]byte, error) { + // Pack up the request into an RPC argument + args := struct { + To common.Address `json:"to"` + Data string `json:"data"` + }{ + To: contract, + Data: common.ToHex(data), + } + // Execute the RPC call and retrieve the response + block := "latest" + if pending { + block = "pending" + } + res, err := b.request("eth_call", []interface{}{args, block}) + if err != nil { + return nil, err + } + var hex string + if err := json.Unmarshal(res, &hex); err != nil { + return nil, err + } + // Convert the response back to a Go byte slice and return + return common.FromHex(hex), nil +} + +// AccountNonce implements ContractTransactor.AccountNonce, delegating the +// current account nonce retrieval to the remote node. +func (b *rpcBackend) AccountNonce(account common.Address) (uint64, error) { + res, err := b.request("eth_getTransactionCount", []interface{}{account.Hex(), "pending"}) + if err != nil { + return 0, err + } + var hex string + if err := json.Unmarshal(res, &hex); err != nil { + return 0, err + } + return new(big.Int).SetBytes(common.FromHex(hex)).Uint64(), nil +} + +// GasPrice implements ContractTransactor.GasPrice, delegating the gas price +// oracle request to the remote node. +func (b *rpcBackend) GasPrice() (*big.Int, error) { + res, err := b.request("eth_gasPrice", nil) + if err != nil { + return nil, err + } + var hex string + if err := json.Unmarshal(res, &hex); err != nil { + return nil, err + } + return new(big.Int).SetBytes(common.FromHex(hex)), nil +} + +// GasLimit implements ContractTransactor.GasLimit, delegating the gas estimation +// to the remote node. +func (b *rpcBackend) GasLimit(sender common.Address, contract *common.Address, value *big.Int, data []byte) (*big.Int, error) { + // Pack up the request into an RPC argument + args := struct { + From common.Address `json:"from"` + To *common.Address `json:"to"` + Value *rpc.HexNumber `json:"value"` + Data string `json:"data"` + }{ + From: sender, + To: contract, + Data: common.ToHex(data), + Value: rpc.NewHexNumber(value), + } + // Execute the RPC call and retrieve the response + res, err := b.request("eth_estimateGas", []interface{}{args}) + if err != nil { + return nil, err + } + var hex string + if err := json.Unmarshal(res, &hex); err != nil { + return nil, err + } + // Convert the response back to a Go byte slice and return + return new(big.Int).SetBytes(common.FromHex(hex)), nil +} + +// Transact implements ContractTransactor.SendTransaction, delegating the raw +// transaction injection to the remote node. +func (b *rpcBackend) SendTransaction(tx *types.Transaction) error { + data, err := rlp.EncodeToBytes(tx) + if err != nil { + return err + } + res, err := b.request("eth_sendRawTransaction", []interface{}{common.ToHex(data)}) + if err != nil { + return err + } + var hex string + if err := json.Unmarshal(res, &hex); err != nil { + return err + } + return nil +} diff --git a/accounts/abi/bind/backends/simulated.go b/accounts/abi/bind/backends/simulated.go new file mode 100644 index 000000000..17a0ed7fe --- /dev/null +++ b/accounts/abi/bind/backends/simulated.go @@ -0,0 +1,184 @@ +// 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 backends + +import ( + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/state" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/ethdb" + "github.com/ethereum/go-ethereum/event" +) + +// SimulatedBackend implements bind.ContractBackend, simulating a blockchain in +// the background. Its main purpose is to allow easily testing contract bindings. +type SimulatedBackend struct { + database ethdb.Database // In memory database to store our testing data + blockchain *core.BlockChain // Ethereum blockchain to handle the consensus + + pendingBlock *types.Block // Currently pending block that will be imported on request + pendingState *state.StateDB // Currently pending state that will be the active on on request +} + +// NewSimulatedBackend creates a new binding backend using a simulated blockchain +// for testing purposes. +func NewSimulatedBackend(accounts ...core.GenesisAccount) *SimulatedBackend { + database, _ := ethdb.NewMemDatabase() + core.WriteGenesisBlockForTesting(database, accounts...) + blockchain, _ := core.NewBlockChain(database, new(core.FakePow), new(event.TypeMux)) + + backend := &SimulatedBackend{ + database: database, + blockchain: blockchain, + } + backend.Rollback() + + return backend +} + +// Commit imports all the pending transactions as a single block and starts a +// fresh new state. +func (b *SimulatedBackend) Commit() { + 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 + } + b.Rollback() +} + +// Rollback aborts all pending transactions, reverting to the last committed state. +func (b *SimulatedBackend) Rollback() { + blocks, _ := core.GenerateChain(b.blockchain.CurrentBlock(), b.database, 1, func(int, *core.BlockGen) {}) + + b.pendingBlock = blocks[0] + b.pendingState, _ = state.New(b.pendingBlock.Root(), b.database) +} + +// ContractCall implements ContractCaller.ContractCall, executing the specified +// contract with the given input data. +func (b *SimulatedBackend) ContractCall(contract common.Address, data []byte, pending bool) ([]byte, error) { + // Create a copy of the current state db to screw around with + var ( + block *types.Block + statedb *state.StateDB + ) + if pending { + block, statedb = b.pendingBlock, b.pendingState + } else { + block = b.blockchain.CurrentBlock() + statedb, _ = b.blockchain.State() + } + statedb = statedb.Copy() + + // Set infinite balance to the a fake caller account + from := statedb.GetOrNewStateObject(common.Address{}) + from.SetBalance(common.MaxBig) + + // Assemble the call invocation to measure the gas usage + msg := callmsg{ + from: from, + to: &contract, + gasPrice: new(big.Int), + gasLimit: common.MaxBig, + value: new(big.Int), + data: data, + } + // Execute the call and return + vmenv := core.NewEnv(statedb, b.blockchain, msg, block.Header()) + gaspool := new(core.GasPool).AddGas(common.MaxBig) + + out, _, err := core.ApplyMessage(vmenv, msg, gaspool) + return out, err +} + +// AccountNonce implements ContractTransactor.AccountNonce, retrieving the nonce +// currently pending for the account. +func (b *SimulatedBackend) AccountNonce(account common.Address) (uint64, error) { + return b.pendingState.GetOrNewStateObject(account).Nonce(), nil +} + +// GasPrice implements ContractTransactor.GasPrice. Since the simulated chain +// doens't have miners, we just return a gas price of 1 for any call. +func (b *SimulatedBackend) GasPrice() (*big.Int, error) { + return big.NewInt(1), nil +} + +// GasLimit implements ContractTransactor.GasLimit, executing the requested code +// against the currently pending block/state and returning the used gas. +func (b *SimulatedBackend) GasLimit(sender common.Address, contract *common.Address, value *big.Int, data []byte) (*big.Int, error) { + // Create a copy of the currently pending state db to screw around with + var ( + block = b.pendingBlock + statedb = b.pendingState.Copy() + ) + + // Set infinite balance to the a fake caller account + from := statedb.GetOrNewStateObject(sender) + from.SetBalance(common.MaxBig) + + // Assemble the call invocation to measure the gas usage + msg := callmsg{ + from: from, + to: contract, + gasPrice: new(big.Int), + gasLimit: common.MaxBig, + value: value, + data: data, + } + // Execute the call and return + vmenv := core.NewEnv(statedb, b.blockchain, msg, block.Header()) + gaspool := new(core.GasPool).AddGas(common.MaxBig) + + _, gas, err := core.ApplyMessage(vmenv, msg, gaspool) + return gas, err +} + +// Transact implements ContractTransactor.SendTransaction, delegating the raw +// transaction injection to the remote node. +func (b *SimulatedBackend) SendTransaction(tx *types.Transaction) error { + blocks, _ := core.GenerateChain(b.blockchain.CurrentBlock(), b.database, 1, func(number int, block *core.BlockGen) { + for _, tx := range b.pendingBlock.Transactions() { + block.AddTx(tx) + } + block.AddTx(tx) + }) + b.pendingBlock = blocks[0] + b.pendingState, _ = state.New(b.pendingBlock.Root(), b.database) + + return nil +} + +// callmsg implements core.Message to allow passing it as a transaction simulator. +type callmsg struct { + from *state.StateObject + to *common.Address + gasLimit *big.Int + gasPrice *big.Int + value *big.Int + data []byte +} + +func (m callmsg) From() (common.Address, error) { return m.from.Address(), nil } +func (m callmsg) FromFrontier() (common.Address, error) { return m.from.Address(), nil } +func (m callmsg) Nonce() uint64 { return m.from.Nonce() } +func (m callmsg) To() *common.Address { return m.to } +func (m callmsg) GasPrice() *big.Int { return m.gasPrice } +func (m callmsg) Gas() *big.Int { return m.gasLimit } +func (m callmsg) Value() *big.Int { return m.value } +func (m callmsg) Data() []byte { return m.data } diff --git a/accounts/abi/bind/base.go b/accounts/abi/bind/base.go index 75e3c1d2d..e9e35fbcb 100644 --- a/accounts/abi/bind/base.go +++ b/accounts/abi/bind/base.go @@ -24,14 +24,21 @@ import ( "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" ) // 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) -// AuthOpts is the authorization data required to create a valid Ethereum transaction. -type AuthOpts struct { +// 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 +} + +// TransactOpts is the collection of authorization data required to create a +// valid Ethereum transaction. +type TransactOpts struct { Account 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) @@ -62,16 +69,43 @@ func NewBoundContract(address common.Address, abi abi.ABI, caller ContractCaller } } +// 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) { + // Sanity check the authorization options + if opts == nil { + return common.Address{}, nil, nil, errors.New("transaction options missing") + } + // Otherwise try to deploy the contract + c := NewBoundContract(common.Address{}, abi, backend.(ContractCaller), backend.(ContractTransactor)) + + 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.Account, 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(result interface{}, method string, params ...interface{}) error { +func (c *BoundContract) Call(opts *CallOpts, result interface{}, method string, params ...interface{}) error { + // Don't crash on a lazy user + if opts == nil { + opts = new(CallOpts) + } + // Pack the input, call and unpack the results input, err := c.abi.Pack(method, params...) if err != nil { return err } - output, err := c.caller.ContractCall(c.address, input) + output, err := c.caller.ContractCall(c.address, input, opts.Pending) if err != nil { return err } @@ -80,11 +114,24 @@ func (c *BoundContract) Call(result interface{}, method string, params ...interf // Transact invokes the (paid) contract method with params as input values and // value as the fund transfer to the contract. -func (c *BoundContract) Transact(opts *AuthOpts, method string, params ...interface{}) (*types.Transaction, error) { +func (c *BoundContract) Transact(opts *TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + // Sanity check the authorization options + if opts == nil { + return nil, errors.New("transaction options missing") + } + // Otherwise pack up the parameters and invoke the contract input, err := c.abi.Pack(method, params...) if err != nil { return nil, err } + return c.transact(opts, &c.address, input) +} + +// 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) { + var err error + // Ensure a valid value field and resolve the account nonce value := opts.Value if value == nil { @@ -109,13 +156,18 @@ func (c *BoundContract) Transact(opts *AuthOpts, method string, params ...interf } gasLimit := opts.GasLimit if gasLimit == nil { - gasLimit, err = c.transactor.GasLimit(opts.Account, c.address, value, input) + gasLimit, err = c.transactor.GasLimit(opts.Account, contract, value, input) if err != nil { return nil, fmt.Errorf("failed to exstimate gas needed: %v", err) } } // Create the transaction, sign it and schedule it for execution - rawTx := types.NewTransaction(nonce, c.address, value, gasLimit, gasPrice, input) + var rawTx *types.Transaction + if contract == nil { + rawTx = types.NewContractCreation(nonce, value, gasLimit, gasPrice, input) + } else { + rawTx = types.NewTransaction(nonce, c.address, value, gasLimit, gasPrice, input) + } if opts.Signer == nil { return nil, errors.New("no signer to authorize the transaction with") } diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index bef75a158..5bd230d0d 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -31,16 +31,18 @@ import ( // to be used as is in client code, but rather as an intermediate struct which // enforces compile time type safety and naming convention opposed to having to // manually maintain hard coded strings that break on runtime. -func Bind(jsonABI string, pkg string, kind string) (string, error) { +func Bind(abijson string, bytecode string, pkg string, kind string) (string, error) { // Parse the actual ABI to generate the binding for - abi, err := abi.JSON(strings.NewReader(jsonABI)) + abi, err := abi.JSON(strings.NewReader(abijson)) if err != nil { return "", err } // Generate the contract type, fields and methods code := new(bytes.Buffer) kind = strings.ToUpper(kind[:1]) + kind[1:] - fmt.Fprintf(code, "%s\n", bindContract(kind, jsonABI)) + + fmt.Fprintf(code, "%s\n", bindContract(kind, strings.TrimSpace(abijson))) + fmt.Fprintf(code, "%s\n", bindConstructor(kind, strings.TrimSpace(bytecode), abi.Constructor)) methods := make([]string, 0, len(abi.Methods)) for name, _ := range abi.Methods { @@ -54,12 +56,14 @@ func Bind(jsonABI string, pkg string, kind string) (string, error) { // Format the code with goimports and return buffer := new(bytes.Buffer) + fmt.Fprintf(buffer, "// This file is an automatically generated Go binding based on the contract ABI\n") + fmt.Fprintf(buffer, "// defined in %sABI. Do not modify as any change will likely be lost!\n\n", kind) fmt.Fprintf(buffer, "package %s\n\n", pkg) fmt.Fprintf(buffer, "%s\n\n", string(code.Bytes())) blob, err := imports.Process("", buffer.Bytes(), nil) if err != nil { - return "", err + return "", fmt.Errorf("%v\n%s", err, code) } return string(blob), nil } @@ -67,13 +71,13 @@ func Bind(jsonABI string, pkg string, kind string) (string, error) { // bindContract generates the basic wrapper code for interacting with an Ethereum // contract via the abi package. All contract methods will call into the generic // ones generated here. -func bindContract(kind string, abi string) string { +func bindContract(kind string, abijson string) string { code := "" // Generate the hard coded ABI used for Ethereum interaction - code += fmt.Sprintf("// Ethereum ABI used to generate the binding from.\nconst %sABI = `%s`\n\n", kind, strings.TrimSpace(abi)) + code += fmt.Sprintf("// Ethereum ABI used to generate the binding from.\nconst %sABI = `%s`\n\n", kind, abijson) - // Generate the Go struct with all the maintenance fields + // Generate the high level contract wrapper types code += fmt.Sprintf("// %s is an auto generated Go binding around an Ethereum contract.\n", kind) code += fmt.Sprintf("type %s struct {\n", kind) code += fmt.Sprintf(" %sCaller // Read-only binding to the contract\n", kind) @@ -82,61 +86,122 @@ func bindContract(kind string, abi string) string { code += fmt.Sprintf("// %sCaller is an auto generated read-only Go binding around an Ethereum contract.\n", kind) code += fmt.Sprintf("type %sCaller struct {\n", kind) - code += fmt.Sprintf(" common *common%s // Contract binding common to callers and transactors\n", kind) + code += fmt.Sprintf(" contract *bind.BoundContract // Generic contract wrapper for the low level calls\n") code += fmt.Sprintf("}\n\n") code += fmt.Sprintf("// %sTransactor is an auto generated write-only Go binding around an Ethereum contract.\n", kind) code += fmt.Sprintf("type %sTransactor struct {\n", kind) - code += fmt.Sprintf(" common *common%s // Contract binding common to callers and transactors\n", kind) + code += fmt.Sprintf(" contract *bind.BoundContract // Generic contract wrapper for the low level calls\n") code += fmt.Sprintf("}\n\n") - code += fmt.Sprintf("// common%s is an auto generated Go binding around an Ethereum contract.\n", kind) - code += fmt.Sprintf("type common%s struct {\n", kind) - code += fmt.Sprintf(" contract *bind.BoundContract // Generic contract wrapper for the low level calls\n") + // Generate the high level contract session wrapper types + code += fmt.Sprintf("// %sSession is an auto generated Go binding around an Ethereum contract,\n// with pre-set call and transact options.\n", kind) + code += fmt.Sprintf("type %sSession struct {\n", kind) + code += fmt.Sprintf(" Contract *%s // Generic contract binding to set the session for\n", kind) + code += fmt.Sprintf(" CallOpts bind.CallOpts // Call options to use throughout this session\n") + code += fmt.Sprintf(" TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session\n") + code += fmt.Sprintf("}\n\n") + + code += fmt.Sprintf("// %sCallerSession is an auto generated read-only Go binding around an Ethereum contract,\n// with pre-set call options.\n", kind) + code += fmt.Sprintf("type %sCallerSession struct {\n", kind) + code += fmt.Sprintf(" Contract *%sCaller // Generic contract caller binding to set the session for\n", kind) + code += fmt.Sprintf(" CallOpts bind.CallOpts // Call options to use throughout this session\n") + code += fmt.Sprintf("}\n\n") + + code += fmt.Sprintf("// %sTransactorSession is an auto generated write-only Go binding around an Ethereum contract,\n// with pre-set transact options.\n", kind) + code += fmt.Sprintf("type %sTransactorSession struct {\n", kind) + code += fmt.Sprintf(" Contract *%sTransactor // Generic contract transactor binding to set the session for\n", kind) + code += fmt.Sprintf(" TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session\n") code += fmt.Sprintf("}\n\n") // Generate the constructor to create a bound contract code += fmt.Sprintf("// New%s creates a new instance of %s, bound to a specific deployed contract.\n", kind, kind) code += fmt.Sprintf("func New%s(address common.Address, backend bind.ContractBackend) (*%s, error) {\n", kind, kind) - code += fmt.Sprintf(" common, err := newCommon%s(address, backend.(bind.ContractCaller), backend.(bind.ContractTransactor))\n", kind) + code += fmt.Sprintf(" contract, err := bind%s(address, backend.(bind.ContractCaller), backend.(bind.ContractTransactor))\n", kind) code += fmt.Sprintf(" if err != nil {\n") code += fmt.Sprintf(" return nil, err\n") code += fmt.Sprintf(" }\n") - code += fmt.Sprintf(" return &%s{%sCaller: %sCaller{common: common}, %sTransactor: %sTransactor{common: common}}, nil\n", kind, kind, kind, kind, kind) + code += fmt.Sprintf(" return &%s{%sCaller: %sCaller{contract: contract}, %sTransactor: %sTransactor{contract: contract}}, nil\n", kind, kind, kind, kind, kind) code += fmt.Sprintf("}\n\n") code += fmt.Sprintf("// New%sCaller creates a new read-only instance of %s, bound to a specific deployed contract.\n", kind, kind) code += fmt.Sprintf("func New%sCaller(address common.Address, caller bind.ContractCaller) (*%sCaller, error) {\n", kind, kind) - code += fmt.Sprintf(" common, err := newCommon%s(address, caller, nil)\n", kind) + code += fmt.Sprintf(" contract, err := bind%s(address, caller, nil)\n", kind) code += fmt.Sprintf(" if err != nil {\n") code += fmt.Sprintf(" return nil, err\n") code += fmt.Sprintf(" }\n") - code += fmt.Sprintf(" return &%sCaller{common: common}, nil\n", kind) + code += fmt.Sprintf(" return &%sCaller{contract: contract}, nil\n", kind) code += fmt.Sprintf("}\n\n") code += fmt.Sprintf("// New%sTransactor creates a new write-only instance of %s, bound to a specific deployed contract.\n", kind, kind) code += fmt.Sprintf("func New%sTransactor(address common.Address, transactor bind.ContractTransactor) (*%sTransactor, error) {\n", kind, kind) - code += fmt.Sprintf(" common, err := newCommon%s(address, nil, transactor)\n", kind) + code += fmt.Sprintf(" contract, err := bind%s(address, nil, transactor)\n", kind) code += fmt.Sprintf(" if err != nil {\n") code += fmt.Sprintf(" return nil, err\n") code += fmt.Sprintf(" }\n") - code += fmt.Sprintf(" return &%sTransactor{common: common}, nil\n", kind) + code += fmt.Sprintf(" return &%sTransactor{contract: contract}, nil\n", kind) code += fmt.Sprintf("}\n\n") - code += fmt.Sprintf("// newCommon%s creates an internal instance of %s, bound to a specific deployed contract.\n", kind, kind) - code += fmt.Sprintf("func newCommon%s(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor) (*common%s, error) {\n", kind, kind) + code += fmt.Sprintf("// bind%s binds a generic wrapper to an already deployed contract.\n", kind) + code += fmt.Sprintf("func bind%s(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor) (*bind.BoundContract, error) {\n", kind) code += fmt.Sprintf(" parsed, err := abi.JSON(strings.NewReader(%sABI))\n", kind) code += fmt.Sprintf(" if err != nil {\n") code += fmt.Sprintf(" return nil, err\n") code += fmt.Sprintf(" }\n") - code += fmt.Sprintf(" return &common%s{\n", kind) - code += fmt.Sprintf(" contract: bind.NewBoundContract(address, parsed, caller, transactor),\n") - code += fmt.Sprintf(" }, nil\n") + code += fmt.Sprintf(" return bind.NewBoundContract(address, parsed, caller, transactor), nil\n") code += fmt.Sprintf("}") return code } +// bindConstructor +func bindConstructor(kind string, bytecode string, constructor abi.Method) string { + // If no byte code was supplied, we cannot deploy + if bytecode == "" { + return "" + } + // Otherwise store the bytecode into a global constant + code := fmt.Sprintf("// Ethereum VM bytecode used for deploying new contracts.\nconst %sBin = `%s`\n\n", kind, bytecode) + + // Generate the argument list for the constructor + args := make([]string, 0, len(constructor.Inputs)) + for i, arg := range constructor.Inputs { + param := arg.Name + if param == "" { + param = fmt.Sprintf("arg%d", i) + } + args = append(args, fmt.Sprintf("%s %s", param, bindType(arg.Type))) + } + arglist := "" + if len(args) > 0 { + arglist = "," + strings.Join(args, ",") + } + // Generate the cal parameter list for the dpeloyer + params := make([]string, len(args)) + for i, param := range args { + params[i] = strings.Split(param, " ")[0] + } + paramlist := "" + if len(params) > 0 { + paramlist = "," + strings.Join(params, ",") + } + // And generate the global deployment function + code += fmt.Sprintf("// Deploy%s deploys a new contract, binding an instance of %s to it.\n", kind, kind) + code += fmt.Sprintf("func Deploy%s(auth *bind.TransactOpts, backend bind.ContractBackend %s) (common.Address, *types.Transaction, *%s, error) {\n", kind, arglist, kind) + code += fmt.Sprintf(" parsed, err := abi.JSON(strings.NewReader(%sABI))\n", kind) + code += fmt.Sprintf(" if err != nil {\n") + code += fmt.Sprintf(" return common.Address{}, nil, nil, err\n") + code += fmt.Sprintf(" }\n") + code += fmt.Sprintf(" address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(%sBin), backend %s)\n", kind, paramlist) + code += fmt.Sprintf(" if err != nil {\n") + code += fmt.Sprintf(" return common.Address{}, nil, nil, err\n") + code += fmt.Sprintf(" }\n") + code += fmt.Sprintf(" return address, tx, &%s{%sCaller: %sCaller{contract: contract}, %sTransactor: %sTransactor{contract: contract}}, nil\n", kind, kind, kind, kind, kind) + code += fmt.Sprintf("}\n\n") + + return code +} + // bindMethod func bindMethod(kind string, method abi.Method) string { var ( @@ -163,13 +228,55 @@ func bindMethod(kind string, method abi.Method) string { docs += fmt.Sprintf("// \n") docs += fmt.Sprintf("// Solidity: %s", strings.TrimPrefix(method.String(), "function ")) + // Generate the passthrough argument list for sessions + params := make([]string, len(args)) + for i, param := range args { + params[i] = strings.Split(param, " ")[0] + } + sessargs := "" + if len(params) > 0 { + sessargs = "," + strings.Join(params, ",") + } // Generate the method itself for both the read/write version and the combo too code := fmt.Sprintf("%s\n", prologue) if method.Const { - code += fmt.Sprintf("%s\nfunc (_%s *%sCaller) %s(%s) (%s) {\n%s\n}\n", docs, kind, kind, name, strings.Join(args, ","), strings.Join(returns, ","), bindCallBody(kind, method.Name, args, returns)) + // Create the main call implementation + callargs := append([]string{"opts *bind.CallOpts"}, args...) + + code += fmt.Sprintf("%s\n", docs) + code += fmt.Sprintf("func (_%s *%sCaller) %s(%s) (%s) {\n", kind, kind, name, strings.Join(callargs, ","), strings.Join(returns, ",")) + code += fmt.Sprintf(" %s\n", bindCallBody(kind, method.Name, callargs, returns)) + code += fmt.Sprintf("}\n\n") + + // Create the wrapping session call implementation + code += fmt.Sprintf("%s\n", docs) + code += fmt.Sprintf("func (_%s *%sSession) %s(%s) (%s) {\n", kind, kind, name, strings.Join(args, ","), strings.Join(returns, ",")) + code += fmt.Sprintf(" return _%s.Contract.%s(&_%s.CallOpts %s)\n", kind, name, kind, sessargs) + code += fmt.Sprintf("}\n\n") + + code += fmt.Sprintf("%s\n", docs) + code += fmt.Sprintf("func (_%s *%sCallerSession) %s(%s) (%s) {\n", kind, kind, name, strings.Join(args, ","), strings.Join(returns, ",")) + code += fmt.Sprintf(" return _%s.Contract.%s(&_%s.CallOpts %s)\n", kind, name, kind, sessargs) + code += fmt.Sprintf("}\n\n") } else { - args = append([]string{"auth *bind.AuthOpts"}, args...) - code += fmt.Sprintf("%s\nfunc (_%s *%sTransactor) %s(%s) (*types.Transaction, error) {\n%s\n}\n", docs, kind, kind, name, strings.Join(args, ","), bindTransactionBody(kind, method.Name, args)) + // Create the main transaction implementation + txargs := append([]string{"opts *bind.TransactOpts"}, args...) + + code += fmt.Sprintf("%s\n", docs) + code += fmt.Sprintf("func (_%s *%sTransactor) %s(%s) (*types.Transaction, error) {\n", kind, kind, name, strings.Join(txargs, ",")) + code += fmt.Sprintf(" %s\n", bindTransactionBody(kind, method.Name, txargs)) + code += fmt.Sprintf("}\n\n") + + // Create the wrapping session call implementation + code += fmt.Sprintf("%s\n", docs) + code += fmt.Sprintf("func (_%s *%sSession) %s(%s) (*types.Transaction, error) {\n", kind, kind, name, strings.Join(args, ",")) + code += fmt.Sprintf(" return _%s.Contract.%s(&_%s.TransactOpts %s)\n", kind, name, kind, sessargs) + code += fmt.Sprintf("}\n\n") + + code += fmt.Sprintf("%s\n", docs) + code += fmt.Sprintf("func (_%s *%sTransactorSession) %s(%s) (*types.Transaction, error) {\n", kind, kind, name, strings.Join(args, ",")) + code += fmt.Sprintf(" return _%s.Contract.%s(&_%s.TransactOpts %s)\n", kind, name, kind, sessargs) + code += fmt.Sprintf("}\n\n") } return code } @@ -264,7 +371,7 @@ func bindCallBody(kind string, method string, params []string, returns []string) name := fmt.Sprintf("ret%d", i) rets = append(rets, name) - body += fmt.Sprintf("%s = new(%s)\n", name, strings.TrimPrefix(kind, "*")) + body += fmt.Sprintf("%s = new(%s)\n", name, kind) } body += ")\n" } @@ -274,8 +381,8 @@ func bindCallBody(kind string, method string, params []string, returns []string) result = "[]interface{}{" + result + "}" } // Extract the parameter list into a flat variable name list - inputs := make([]string, len(params)) - for i, param := range params { + inputs := make([]string, len(params)-1) // Omit the call options + for i, param := range params[1:] { inputs[i] = strings.Split(param, " ")[0] } input := "" @@ -283,15 +390,11 @@ func bindCallBody(kind string, method string, params []string, returns []string) input = "," + strings.Join(inputs, ",") } // Request executing the contract call and return the results with the errors - body += fmt.Sprintf("err := _%s.common.contract.Call(%s, \"%s\" %s)\n", kind, result, method, input) + body += fmt.Sprintf("err := _%s.contract.Call(opts, %s, \"%s\" %s)\n", kind, result, method, input) outs := make([]string, 0, len(returns)) - for i, ret := range returns[:len(returns)-1] { // Handle th final error separately - if strings.HasPrefix(ret, "*") { - outs = append(outs, rets[i]) - } else { - outs = append(outs, "*"+rets[i]) - } + for _, ret := range rets { // Handle th final error separately + outs = append(outs, "*"+ret) } outs = append(outs, "err") @@ -313,5 +416,5 @@ func bindTransactionBody(kind string, method string, params []string) string { input = "," + strings.Join(inputs, ",") } // Request executing the contract call and return the results with the errors - return fmt.Sprintf("return _%s.common.contract.Transact(auth, \"%s\" %s)", kind, method, input) + return fmt.Sprintf("return _%s.contract.Transact(opts, \"%s\" %s)", kind, method, input) } diff --git a/accounts/abi/bind/bind_test.go b/accounts/abi/bind/bind_test.go index f13f7829e..a86d39db7 100644 --- a/accounts/abi/bind/bind_test.go +++ b/accounts/abi/bind/bind_test.go @@ -43,13 +43,13 @@ var bindTests = []struct { `contract NilContract {}`, `606060405260068060106000396000f3606060405200`, `[]`, - `if b, err := NewEmpty(common.Address{}, bind.NilBackend); b == nil || err != nil { + `if b, err := NewEmpty(common.Address{}, backends.NewNilBackend()); b == nil || err != nil { t.Fatalf("combined binding (%v) nil or error (%v) not nil", b, nil) } - if b, err := NewEmptyCaller(common.Address{}, bind.NilBackend); b == nil || err != nil { + if b, err := NewEmptyCaller(common.Address{}, backends.NewNilBackend()); b == nil || err != nil { t.Fatalf("caller binding (%v) nil or error (%v) not nil", b, nil) } - if b, err := NewEmptyTransactor(common.Address{}, bind.NilBackend); b == nil || err != nil { + if b, err := NewEmptyTransactor(common.Address{}, backends.NewNilBackend()); b == nil || err != nil { t.Fatalf("transactor binding (%v) nil or error (%v) not nil", b, nil) }`, }, @@ -59,7 +59,7 @@ var bindTests = []struct { `https://ethereum.org/token`, `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`, `[{"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"}]`, - `if b, err := NewToken(common.Address{}, bind.NilBackend); b == nil || err != nil { + `if b, err := NewToken(common.Address{}, backends.NewNilBackend()); b == nil || err != nil { t.Fatalf("binding (%v) nil or error (%v) not nil", b, nil) }`, }, @@ -68,7 +68,7 @@ var bindTests = []struct { `https://ethereum.org/crowdsale`, `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`, `[{"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"}]`, - `if b, err := NewCrowdsale(common.Address{}, bind.NilBackend); b == nil || err != nil { + `if b, err := NewCrowdsale(common.Address{}, backends.NewNilBackend()); b == nil || err != nil { t.Fatalf("binding (%v) nil or error (%v) not nil", b, nil) }`, }, @@ -77,7 +77,7 @@ var bindTests = []struct { `https://ethereum.org/dao`, `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`, `[{"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"}]`, - `if b, err := NewDAO(common.Address{}, bind.NilBackend); b == nil || err != nil { + `if b, err := NewDAO(common.Address{}, backends.NewNilBackend()); b == nil || err != nil { t.Fatalf("binding (%v) nil or error (%v) not nil", b, nil) }`, }, @@ -92,7 +92,7 @@ func TestBindings(t *testing.T) { t.Skip("go sdk not found for testing") } // Skip the test if the go-ethereum sources are symlinked (https://github.com/golang/go/issues/14845) - linkTestCode := fmt.Sprintf("package linktest\nfunc CheckSymlinks(){\nfmt.Println(bind.NilBackend)\n}") + linkTestCode := fmt.Sprintf("package linktest\nfunc CheckSymlinks(){\nfmt.Println(backends.NewNilBackend())\n}") linkTestDeps, err := imports.Process("", []byte(linkTestCode), nil) if err != nil { t.Fatalf("failed check for goimports symlink bug: %v", err) @@ -110,7 +110,7 @@ func TestBindings(t *testing.T) { defer os.RemoveAll(ws) // Generate the binding and create a Go package in the workspace - bind, err := Bind(tt.abi, "bindtest", tt.name) + bind, err := Bind(tt.abi, tt.bytecode, "bindtest", tt.name) if err != nil { t.Fatalf("test %d: failed to generate binding: %v", i, err) } -- cgit v1.2.3 From 73308dbe0e08db015a7c461b5be1755dc3fcc737 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?P=C3=A9ter=20Szil=C3=A1gyi?= Date: Mon, 21 Mar 2016 14:34:49 +0200 Subject: accounts/abi/bind, cmd/abigen: port to templates, bind to solidity --- accounts/abi/bind/auth.go | 14 +- accounts/abi/bind/backend.go | 20 +- accounts/abi/bind/backends/nil.go | 11 +- accounts/abi/bind/backends/remote.go | 66 +++-- accounts/abi/bind/backends/simulated.go | 33 +-- accounts/abi/bind/base.go | 26 +- accounts/abi/bind/bind.go | 421 +++++++------------------------- accounts/abi/bind/bind_test.go | 155 ++++++++++-- accounts/abi/bind/template.go | 212 ++++++++++++++++ 9 files changed, 530 insertions(+), 428 deletions(-) create mode 100644 accounts/abi/bind/template.go (limited to 'accounts/abi') diff --git a/accounts/abi/bind/auth.go b/accounts/abi/bind/auth.go index e0491497c..624f995b0 100644 --- a/accounts/abi/bind/auth.go +++ b/accounts/abi/bind/auth.go @@ -18,6 +18,8 @@ package bind import ( "errors" + "io" + "io/ioutil" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" @@ -25,9 +27,13 @@ import ( ) // NewTransactor is a utility method to easily create a transaction signer from -// an encrypted json key file and the associated passphrase. -func NewTransactor(keyjson string, passphrase string) (*TransactOpts, error) { - key, err := crypto.DecryptKey([]byte(keyjson), passphrase) +// an encrypted json key stream and the associated passphrase. +func NewTransactor(keyin io.Reader, passphrase string) (*TransactOpts, error) { + json, err := ioutil.ReadAll(keyin) + if err != nil { + return nil, err + } + key, err := crypto.DecryptKey(json, passphrase) if err != nil { return nil, err } @@ -38,7 +44,7 @@ func NewTransactor(keyjson string, passphrase string) (*TransactOpts, error) { // from a plain go-ethereum crypto key. func NewKeyedTransactor(key *crypto.Key) *TransactOpts { return &TransactOpts{ - Account: key.Address, + From: key.Address, Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) { if address != key.Address { return nil, errors.New("not authorized to sign this account") diff --git a/accounts/abi/bind/backend.go b/accounts/abi/bind/backend.go index 596e97f1d..328f9f3b7 100644 --- a/accounts/abi/bind/backend.go +++ b/accounts/abi/bind/backend.go @@ -38,14 +38,18 @@ type ContractCaller interface { // to the transactor to decide. type ContractTransactor interface { // Nonce retrieves the current pending nonce associated with an account. - AccountNonce(account common.Address) (uint64, error) - - // GasPrice retrieves the currently suggested gas price to allow a timely execution - // of a transaction. - GasPrice() (*big.Int, error) - - // GasLimit tries to estimate the gas needed to execute a specific transaction. - GasLimit(sender common.Address, contract *common.Address, value *big.Int, data []byte) (*big.Int, error) + PendingAccountNonce(account common.Address) (uint64, error) + + // SuggestGasPrice retrieves the currently suggested gas price to allow a timely + // execution of a transaction. + SuggestGasPrice() (*big.Int, error) + + // EstimateGasLimit 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. + EstimateGasLimit(sender common.Address, contract *common.Address, value *big.Int, data []byte) (*big.Int, error) // SendTransaction injects the transaction into the pending pool for execution. SendTransaction(*types.Transaction) error diff --git a/accounts/abi/bind/backends/nil.go b/accounts/abi/bind/backends/nil.go index 8b1f9d63e..3b1e6dce7 100644 --- a/accounts/abi/bind/backends/nil.go +++ b/accounts/abi/bind/backends/nil.go @@ -24,6 +24,9 @@ import ( "github.com/ethereum/go-ethereum/core/types" ) +// This nil assignment ensures compile time that nilBackend implements bind.ContractBackend. +var _ bind.ContractBackend = (*nilBackend)(nil) + // nilBackend implements bind.ContractBackend, but panics on any method call. // Its sole purpose is to support the binding tests to construct the generated // wrappers without calling any methods on them. @@ -32,12 +35,12 @@ type nilBackend struct{} func (*nilBackend) ContractCall(common.Address, []byte, bool) ([]byte, error) { panic("not implemented") } -func (*nilBackend) GasLimit(common.Address, *common.Address, *big.Int, []byte) (*big.Int, error) { +func (*nilBackend) EstimateGasLimit(common.Address, *common.Address, *big.Int, []byte) (*big.Int, error) { panic("not implemented") } -func (*nilBackend) GasPrice() (*big.Int, error) { panic("not implemented") } -func (*nilBackend) AccountNonce(common.Address) (uint64, error) { panic("not implemented") } -func (*nilBackend) SendTransaction(*types.Transaction) error { panic("not implemented") } +func (*nilBackend) SuggestGasPrice() (*big.Int, error) { panic("not implemented") } +func (*nilBackend) PendingAccountNonce(common.Address) (uint64, error) { panic("not implemented") } +func (*nilBackend) SendTransaction(*types.Transaction) error { panic("not implemented") } // NewNilBackend creates a new binding backend that can be used for instantiation // but will panic on any invocation. Its sole purpose is to help testing. diff --git a/accounts/abi/bind/backends/remote.go b/accounts/abi/bind/backends/remote.go index 7177809bb..8e990f076 100644 --- a/accounts/abi/bind/backends/remote.go +++ b/accounts/abi/bind/backends/remote.go @@ -30,6 +30,9 @@ import ( "github.com/ethereum/go-ethereum/rpc" ) +// This nil assignment ensures compile time that rpcBackend implements bind.ContractBackend. +var _ bind.ContractBackend = (*rpcBackend)(nil) + // rpcBackend implements bind.ContractBackend, and acts as the data provider to // Ethereum contracts bound to Go structs. It uses an RPC connection to delegate // all its functionality. @@ -53,16 +56,16 @@ func NewRPCBackend(client rpc.Client) bind.ContractBackend { // request is a JSON RPC request package assembled internally from the client // method calls. type request struct { - JsonRpc string `json:"jsonrpc"` // Version of the JSON RPC protocol, always set to 2.0 - Id int `json:"id"` // Auto incrementing ID number for this request + JSONRPC string `json:"jsonrpc"` // Version of the JSON RPC protocol, always set to 2.0 + ID int `json:"id"` // Auto incrementing ID number for this request Method string `json:"method"` // Remote procedure name to invoke on the server Params []interface{} `json:"params"` // List of parameters to pass through (keep types simple) } // response is a JSON RPC response package sent back from the API server. type response struct { - JsonRpc string `json:"jsonrpc"` // Version of the JSON RPC protocol, always set to 2.0 - Id int `json:"id"` // Auto incrementing ID number for this request + JSONRPC string `json:"jsonrpc"` // Version of the JSON RPC protocol, always set to 2.0 + ID int `json:"id"` // Auto incrementing ID number for this request Error json.RawMessage `json:"error"` // Any error returned by the remote side Result json.RawMessage `json:"result"` // Whatever the remote side sends us in reply } @@ -71,9 +74,9 @@ type response struct { // // This is currently painfully non-concurrent, but it will have to do until we // find the time for niceties like this :P -func (backend *rpcBackend) request(method string, params []interface{}) (json.RawMessage, error) { - backend.lock.Lock() - defer backend.lock.Unlock() +func (b *rpcBackend) request(method string, params []interface{}) (json.RawMessage, error) { + b.lock.Lock() + defer b.lock.Unlock() // Ugly hack to serialize an empty list properly if params == nil { @@ -81,16 +84,16 @@ func (backend *rpcBackend) request(method string, params []interface{}) (json.Ra } // Assemble the request object req := &request{ - JsonRpc: "2.0", - Id: int(atomic.AddUint32(&backend.autoid, 1)), + JSONRPC: "2.0", + ID: int(atomic.AddUint32(&b.autoid, 1)), Method: method, Params: params, } - if err := backend.client.Send(req); err != nil { + if err := b.client.Send(req); err != nil { return nil, err } res := new(response) - if err := backend.client.Recv(res); err != nil { + if err := b.client.Recv(res); err != nil { return nil, err } if len(res.Error) > 0 { @@ -127,9 +130,9 @@ func (b *rpcBackend) ContractCall(contract common.Address, data []byte, pending return common.FromHex(hex), nil } -// AccountNonce implements ContractTransactor.AccountNonce, delegating the -// current account nonce retrieval to the remote node. -func (b *rpcBackend) AccountNonce(account common.Address) (uint64, error) { +// PendingAccountNonce implements ContractTransactor.PendingAccountNonce, delegating +// the current account nonce retrieval to the remote node. +func (b *rpcBackend) PendingAccountNonce(account common.Address) (uint64, error) { res, err := b.request("eth_getTransactionCount", []interface{}{account.Hex(), "pending"}) if err != nil { return 0, err @@ -138,12 +141,16 @@ func (b *rpcBackend) AccountNonce(account common.Address) (uint64, error) { if err := json.Unmarshal(res, &hex); err != nil { return 0, err } - return new(big.Int).SetBytes(common.FromHex(hex)).Uint64(), nil + nonce, ok := new(big.Int).SetString(hex, 0) + if !ok { + return 0, fmt.Errorf("invalid nonce hex: %s", hex) + } + return nonce.Uint64(), nil } -// GasPrice implements ContractTransactor.GasPrice, delegating the gas price -// oracle request to the remote node. -func (b *rpcBackend) GasPrice() (*big.Int, error) { +// SuggestGasPrice implements ContractTransactor.SuggestGasPrice, delegating the +// gas price oracle request to the remote node. +func (b *rpcBackend) SuggestGasPrice() (*big.Int, error) { res, err := b.request("eth_gasPrice", nil) if err != nil { return nil, err @@ -152,12 +159,16 @@ func (b *rpcBackend) GasPrice() (*big.Int, error) { if err := json.Unmarshal(res, &hex); err != nil { return nil, err } - return new(big.Int).SetBytes(common.FromHex(hex)), nil + price, ok := new(big.Int).SetString(hex, 0) + if !ok { + return nil, fmt.Errorf("invalid price hex: %s", hex) + } + return price, nil } -// GasLimit implements ContractTransactor.GasLimit, delegating the gas estimation -// to the remote node. -func (b *rpcBackend) GasLimit(sender common.Address, contract *common.Address, value *big.Int, data []byte) (*big.Int, error) { +// EstimateGasLimit implements ContractTransactor.EstimateGasLimit, delegating +// the gas estimation to the remote node. +func (b *rpcBackend) EstimateGasLimit(sender common.Address, contract *common.Address, value *big.Int, data []byte) (*big.Int, error) { // Pack up the request into an RPC argument args := struct { From common.Address `json:"from"` @@ -179,12 +190,15 @@ func (b *rpcBackend) GasLimit(sender common.Address, contract *common.Address, v if err := json.Unmarshal(res, &hex); err != nil { return nil, err } - // Convert the response back to a Go byte slice and return - return new(big.Int).SetBytes(common.FromHex(hex)), nil + estimate, ok := new(big.Int).SetString(hex, 0) + if !ok { + return nil, fmt.Errorf("invalid estimate hex: %s", hex) + } + return estimate, nil } -// Transact implements ContractTransactor.SendTransaction, delegating the raw -// transaction injection to the remote node. +// SendTransaction implements ContractTransactor.SendTransaction, delegating the +// raw transaction injection to the remote node. func (b *rpcBackend) SendTransaction(tx *types.Transaction) error { data, err := rlp.EncodeToBytes(tx) if err != nil { diff --git a/accounts/abi/bind/backends/simulated.go b/accounts/abi/bind/backends/simulated.go index 17a0ed7fe..18e8481c5 100644 --- a/accounts/abi/bind/backends/simulated.go +++ b/accounts/abi/bind/backends/simulated.go @@ -19,6 +19,7 @@ package backends import ( "math/big" + "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/state" @@ -27,6 +28,9 @@ import ( "github.com/ethereum/go-ethereum/event" ) +// This nil assignment ensures compile time that SimulatedBackend implements bind.ContractBackend. +var _ bind.ContractBackend = (*SimulatedBackend)(nil) + // SimulatedBackend implements bind.ContractBackend, simulating a blockchain in // the background. Its main purpose is to allow easily testing contract bindings. type SimulatedBackend struct { @@ -79,13 +83,11 @@ func (b *SimulatedBackend) ContractCall(contract common.Address, data []byte, pe statedb *state.StateDB ) if pending { - block, statedb = b.pendingBlock, b.pendingState + block, statedb = b.pendingBlock, b.pendingState.Copy() } else { block = b.blockchain.CurrentBlock() statedb, _ = b.blockchain.State() } - statedb = statedb.Copy() - // Set infinite balance to the a fake caller account from := statedb.GetOrNewStateObject(common.Address{}) from.SetBalance(common.MaxBig) @@ -100,28 +102,29 @@ func (b *SimulatedBackend) ContractCall(contract common.Address, data []byte, pe data: data, } // Execute the call and return - vmenv := core.NewEnv(statedb, b.blockchain, msg, block.Header()) + vmenv := core.NewEnv(statedb, b.blockchain, msg, block.Header(), nil) gaspool := new(core.GasPool).AddGas(common.MaxBig) out, _, err := core.ApplyMessage(vmenv, msg, gaspool) return out, err } -// AccountNonce implements ContractTransactor.AccountNonce, retrieving the nonce -// currently pending for the account. -func (b *SimulatedBackend) AccountNonce(account common.Address) (uint64, error) { +// PendingAccountNonce implements ContractTransactor.PendingAccountNonce, retrieving +// the nonce currently pending for the account. +func (b *SimulatedBackend) PendingAccountNonce(account common.Address) (uint64, error) { return b.pendingState.GetOrNewStateObject(account).Nonce(), nil } -// GasPrice implements ContractTransactor.GasPrice. Since the simulated chain -// doens't have miners, we just return a gas price of 1 for any call. -func (b *SimulatedBackend) GasPrice() (*big.Int, error) { +// SuggestGasPrice implements ContractTransactor.SuggestGasPrice. Since the simulated +// chain doens't have miners, we just return a gas price of 1 for any call. +func (b *SimulatedBackend) SuggestGasPrice() (*big.Int, error) { return big.NewInt(1), nil } -// GasLimit implements ContractTransactor.GasLimit, executing the requested code -// against the currently pending block/state and returning the used gas. -func (b *SimulatedBackend) GasLimit(sender common.Address, contract *common.Address, value *big.Int, data []byte) (*big.Int, error) { +// EstimateGasLimit implements ContractTransactor.EstimateGasLimit, executing the +// requested code against the currently pending block/state and returning the used +// gas. +func (b *SimulatedBackend) EstimateGasLimit(sender common.Address, contract *common.Address, value *big.Int, data []byte) (*big.Int, error) { // Create a copy of the currently pending state db to screw around with var ( block = b.pendingBlock @@ -142,14 +145,14 @@ func (b *SimulatedBackend) GasLimit(sender common.Address, contract *common.Addr data: data, } // Execute the call and return - vmenv := core.NewEnv(statedb, b.blockchain, msg, block.Header()) + vmenv := core.NewEnv(statedb, b.blockchain, msg, block.Header(), nil) gaspool := new(core.GasPool).AddGas(common.MaxBig) _, gas, err := core.ApplyMessage(vmenv, msg, gaspool) return gas, err } -// Transact implements ContractTransactor.SendTransaction, delegating the raw +// SendTransaction implements ContractTransactor.SendTransaction, delegating the raw // transaction injection to the remote node. func (b *SimulatedBackend) SendTransaction(tx *types.Transaction) error { blocks, _ := core.GenerateChain(b.blockchain.CurrentBlock(), b.database, 1, func(number int, block *core.BlockGen) { diff --git a/accounts/abi/bind/base.go b/accounts/abi/bind/base.go index e9e35fbcb..053b4ccc0 100644 --- a/accounts/abi/bind/base.go +++ b/accounts/abi/bind/base.go @@ -39,9 +39,9 @@ type CallOpts struct { // TransactOpts is the collection of authorization data required to create a // valid Ethereum transaction. type TransactOpts struct { - Account 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) + 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 along the transaction (nil = 0 = no funds) GasPrice *big.Int // Gas price to use for the transaction execution (nil = gas price oracle) @@ -72,12 +72,8 @@ func NewBoundContract(address common.Address, abi abi.ABI, caller ContractCaller // 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) { - // Sanity check the authorization options - if opts == nil { - return common.Address{}, nil, nil, errors.New("transaction options missing") - } // Otherwise try to deploy the contract - c := NewBoundContract(common.Address{}, abi, backend.(ContractCaller), backend.(ContractTransactor)) + c := NewBoundContract(common.Address{}, abi, backend, backend) input, err := c.abi.Pack("", params...) if err != nil { @@ -87,7 +83,7 @@ func DeployContract(opts *TransactOpts, abi abi.ABI, bytecode []byte, backend Co if err != nil { return common.Address{}, nil, nil, err } - c.address = crypto.CreateAddress(opts.Account, tx.Nonce()) + c.address = crypto.CreateAddress(opts.From, tx.Nonce()) return c.address, tx, c, nil } @@ -115,10 +111,6 @@ func (c *BoundContract) Call(opts *CallOpts, result interface{}, method string, // Transact invokes the (paid) contract method with params as input values and // value as the fund transfer to the contract. func (c *BoundContract) Transact(opts *TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - // Sanity check the authorization options - if opts == nil { - return nil, errors.New("transaction options missing") - } // Otherwise pack up the parameters and invoke the contract input, err := c.abi.Pack(method, params...) if err != nil { @@ -139,7 +131,7 @@ func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, i } nonce := uint64(0) if opts.Nonce == nil { - nonce, err = c.transactor.AccountNonce(opts.Account) + nonce, err = c.transactor.PendingAccountNonce(opts.From) if err != nil { return nil, fmt.Errorf("failed to retrieve account nonce: %v", err) } @@ -149,14 +141,14 @@ func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, i // Figure out the gas allowance and gas price values gasPrice := opts.GasPrice if gasPrice == nil { - gasPrice, err = c.transactor.GasPrice() + gasPrice, err = c.transactor.SuggestGasPrice() if err != nil { return nil, fmt.Errorf("failed to suggest gas price: %v", err) } } gasLimit := opts.GasLimit if gasLimit == nil { - gasLimit, err = c.transactor.GasLimit(opts.Account, contract, value, input) + gasLimit, err = c.transactor.EstimateGasLimit(opts.From, contract, value, input) if err != nil { return nil, fmt.Errorf("failed to exstimate gas needed: %v", err) } @@ -171,7 +163,7 @@ func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, i if opts.Signer == nil { return nil, errors.New("no signer to authorize the transaction with") } - signedTx, err := opts.Signer(opts.Account, rawTx) + signedTx, err := opts.Signer(opts.From, rawTx) if err != nil { return nil, err } diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index 5bd230d0d..8b587f1aa 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -15,13 +15,17 @@ // 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" - "sort" "strings" + "text/template" + "unicode" "github.com/ethereum/go-ethereum/accounts/abi" "golang.org/x/tools/imports" @@ -31,254 +35,84 @@ import ( // to be used as is in client code, but rather as an intermediate struct which // enforces compile time type safety and naming convention opposed to having to // manually maintain hard coded strings that break on runtime. -func Bind(abijson string, bytecode string, pkg string, kind string) (string, error) { - // Parse the actual ABI to generate the binding for - abi, err := abi.JSON(strings.NewReader(abijson)) - if err != nil { - return "", err - } - // Generate the contract type, fields and methods - code := new(bytes.Buffer) - kind = strings.ToUpper(kind[:1]) + kind[1:] - - fmt.Fprintf(code, "%s\n", bindContract(kind, strings.TrimSpace(abijson))) - fmt.Fprintf(code, "%s\n", bindConstructor(kind, strings.TrimSpace(bytecode), abi.Constructor)) - - methods := make([]string, 0, len(abi.Methods)) - for name, _ := range abi.Methods { - methods = append(methods, name) - } - sort.Strings(methods) - - for _, method := range methods { - fmt.Fprintf(code, "%s\n", bindMethod(kind, abi.Methods[method])) - } - // Format the code with goimports and return - buffer := new(bytes.Buffer) - - fmt.Fprintf(buffer, "// This file is an automatically generated Go binding based on the contract ABI\n") - fmt.Fprintf(buffer, "// defined in %sABI. Do not modify as any change will likely be lost!\n\n", kind) - fmt.Fprintf(buffer, "package %s\n\n", pkg) - fmt.Fprintf(buffer, "%s\n\n", string(code.Bytes())) - - blob, err := imports.Process("", buffer.Bytes(), nil) - if err != nil { - return "", fmt.Errorf("%v\n%s", err, code) - } - return string(blob), nil -} - -// bindContract generates the basic wrapper code for interacting with an Ethereum -// contract via the abi package. All contract methods will call into the generic -// ones generated here. -func bindContract(kind string, abijson string) string { - code := "" - - // Generate the hard coded ABI used for Ethereum interaction - code += fmt.Sprintf("// Ethereum ABI used to generate the binding from.\nconst %sABI = `%s`\n\n", kind, abijson) - - // Generate the high level contract wrapper types - code += fmt.Sprintf("// %s is an auto generated Go binding around an Ethereum contract.\n", kind) - code += fmt.Sprintf("type %s struct {\n", kind) - code += fmt.Sprintf(" %sCaller // Read-only binding to the contract\n", kind) - code += fmt.Sprintf(" %sTransactor // Write-only binding to the contract\n", kind) - code += fmt.Sprintf("}\n\n") - - code += fmt.Sprintf("// %sCaller is an auto generated read-only Go binding around an Ethereum contract.\n", kind) - code += fmt.Sprintf("type %sCaller struct {\n", kind) - code += fmt.Sprintf(" contract *bind.BoundContract // Generic contract wrapper for the low level calls\n") - code += fmt.Sprintf("}\n\n") - - code += fmt.Sprintf("// %sTransactor is an auto generated write-only Go binding around an Ethereum contract.\n", kind) - code += fmt.Sprintf("type %sTransactor struct {\n", kind) - code += fmt.Sprintf(" contract *bind.BoundContract // Generic contract wrapper for the low level calls\n") - code += fmt.Sprintf("}\n\n") - - // Generate the high level contract session wrapper types - code += fmt.Sprintf("// %sSession is an auto generated Go binding around an Ethereum contract,\n// with pre-set call and transact options.\n", kind) - code += fmt.Sprintf("type %sSession struct {\n", kind) - code += fmt.Sprintf(" Contract *%s // Generic contract binding to set the session for\n", kind) - code += fmt.Sprintf(" CallOpts bind.CallOpts // Call options to use throughout this session\n") - code += fmt.Sprintf(" TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session\n") - code += fmt.Sprintf("}\n\n") - - code += fmt.Sprintf("// %sCallerSession is an auto generated read-only Go binding around an Ethereum contract,\n// with pre-set call options.\n", kind) - code += fmt.Sprintf("type %sCallerSession struct {\n", kind) - code += fmt.Sprintf(" Contract *%sCaller // Generic contract caller binding to set the session for\n", kind) - code += fmt.Sprintf(" CallOpts bind.CallOpts // Call options to use throughout this session\n") - code += fmt.Sprintf("}\n\n") - - code += fmt.Sprintf("// %sTransactorSession is an auto generated write-only Go binding around an Ethereum contract,\n// with pre-set transact options.\n", kind) - code += fmt.Sprintf("type %sTransactorSession struct {\n", kind) - code += fmt.Sprintf(" Contract *%sTransactor // Generic contract transactor binding to set the session for\n", kind) - code += fmt.Sprintf(" TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session\n") - code += fmt.Sprintf("}\n\n") - - // Generate the constructor to create a bound contract - code += fmt.Sprintf("// New%s creates a new instance of %s, bound to a specific deployed contract.\n", kind, kind) - code += fmt.Sprintf("func New%s(address common.Address, backend bind.ContractBackend) (*%s, error) {\n", kind, kind) - code += fmt.Sprintf(" contract, err := bind%s(address, backend.(bind.ContractCaller), backend.(bind.ContractTransactor))\n", kind) - code += fmt.Sprintf(" if err != nil {\n") - code += fmt.Sprintf(" return nil, err\n") - code += fmt.Sprintf(" }\n") - code += fmt.Sprintf(" return &%s{%sCaller: %sCaller{contract: contract}, %sTransactor: %sTransactor{contract: contract}}, nil\n", kind, kind, kind, kind, kind) - code += fmt.Sprintf("}\n\n") - - code += fmt.Sprintf("// New%sCaller creates a new read-only instance of %s, bound to a specific deployed contract.\n", kind, kind) - code += fmt.Sprintf("func New%sCaller(address common.Address, caller bind.ContractCaller) (*%sCaller, error) {\n", kind, kind) - code += fmt.Sprintf(" contract, err := bind%s(address, caller, nil)\n", kind) - code += fmt.Sprintf(" if err != nil {\n") - code += fmt.Sprintf(" return nil, err\n") - code += fmt.Sprintf(" }\n") - code += fmt.Sprintf(" return &%sCaller{contract: contract}, nil\n", kind) - code += fmt.Sprintf("}\n\n") - - code += fmt.Sprintf("// New%sTransactor creates a new write-only instance of %s, bound to a specific deployed contract.\n", kind, kind) - code += fmt.Sprintf("func New%sTransactor(address common.Address, transactor bind.ContractTransactor) (*%sTransactor, error) {\n", kind, kind) - code += fmt.Sprintf(" contract, err := bind%s(address, nil, transactor)\n", kind) - code += fmt.Sprintf(" if err != nil {\n") - code += fmt.Sprintf(" return nil, err\n") - code += fmt.Sprintf(" }\n") - code += fmt.Sprintf(" return &%sTransactor{contract: contract}, nil\n", kind) - code += fmt.Sprintf("}\n\n") - - code += fmt.Sprintf("// bind%s binds a generic wrapper to an already deployed contract.\n", kind) - code += fmt.Sprintf("func bind%s(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor) (*bind.BoundContract, error) {\n", kind) - code += fmt.Sprintf(" parsed, err := abi.JSON(strings.NewReader(%sABI))\n", kind) - code += fmt.Sprintf(" if err != nil {\n") - code += fmt.Sprintf(" return nil, err\n") - code += fmt.Sprintf(" }\n") - code += fmt.Sprintf(" return bind.NewBoundContract(address, parsed, caller, transactor), nil\n") - code += fmt.Sprintf("}") - - return code -} - -// bindConstructor -func bindConstructor(kind string, bytecode string, constructor abi.Method) string { - // If no byte code was supplied, we cannot deploy - if bytecode == "" { - return "" - } - // Otherwise store the bytecode into a global constant - code := fmt.Sprintf("// Ethereum VM bytecode used for deploying new contracts.\nconst %sBin = `%s`\n\n", kind, bytecode) - - // Generate the argument list for the constructor - args := make([]string, 0, len(constructor.Inputs)) - for i, arg := range constructor.Inputs { - param := arg.Name - if param == "" { - param = fmt.Sprintf("arg%d", i) +func Bind(types []string, abis []string, bytecodes []string, pkg string) (string, error) { + // Process each individual contract requested binding + contracts := make(map[string]*tmplContract) + + 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 } - args = append(args, fmt.Sprintf("%s %s", param, bindType(arg.Type))) - } - arglist := "" - if len(args) > 0 { - arglist = "," + strings.Join(args, ",") - } - // Generate the cal parameter list for the dpeloyer - params := make([]string, len(args)) - for i, param := range args { - params[i] = strings.Split(param, " ")[0] - } - paramlist := "" - if len(params) > 0 { - paramlist = "," + strings.Join(params, ",") - } - // And generate the global deployment function - code += fmt.Sprintf("// Deploy%s deploys a new contract, binding an instance of %s to it.\n", kind, kind) - code += fmt.Sprintf("func Deploy%s(auth *bind.TransactOpts, backend bind.ContractBackend %s) (common.Address, *types.Transaction, *%s, error) {\n", kind, arglist, kind) - code += fmt.Sprintf(" parsed, err := abi.JSON(strings.NewReader(%sABI))\n", kind) - code += fmt.Sprintf(" if err != nil {\n") - code += fmt.Sprintf(" return common.Address{}, nil, nil, err\n") - code += fmt.Sprintf(" }\n") - code += fmt.Sprintf(" address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(%sBin), backend %s)\n", kind, paramlist) - code += fmt.Sprintf(" if err != nil {\n") - code += fmt.Sprintf(" return common.Address{}, nil, nil, err\n") - code += fmt.Sprintf(" }\n") - code += fmt.Sprintf(" return address, tx, &%s{%sCaller: %sCaller{contract: contract}, %sTransactor: %sTransactor{contract: contract}}, nil\n", kind, kind, kind, kind, kind) - code += fmt.Sprintf("}\n\n") - - return code -} - -// bindMethod -func bindMethod(kind string, method abi.Method) string { - var ( - name = strings.ToUpper(method.Name[:1]) + method.Name[1:] - prologue = new(bytes.Buffer) - ) - // Generate the argument and return list for the function - args := make([]string, 0, len(method.Inputs)) - for i, arg := range method.Inputs { - param := arg.Name - if param == "" { - param = fmt.Sprintf("arg%d", i) + // 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, and sort them alphabetically + var ( + calls = make(map[string]*tmplMethod) + transacts = make(map[string]*tmplMethod) + ) + for _, original := range evmABI.Methods { + // Normalize the method for capital cases and non-anonymous inputs/outputs + normalized := original + normalized.Name = capitalise(original.Name) + + normalized.Inputs = make([]abi.Argument, len(original.Inputs)) + copy(normalized.Inputs, original.Inputs) + for j, input := range normalized.Inputs { + if input.Name == "" { + normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j) + } + } + 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) + } + } + // Append the methos to the call or transact lists + if original.Const { + calls[original.Name] = &tmplMethod{Original: original, Normalized: normalized, Structured: structured(original)} + } else { + transacts[original.Name] = &tmplMethod{Original: original, Normalized: normalized, Structured: structured(original)} + } + } + contracts[types[i]] = &tmplContract{ + Type: capitalise(types[i]), + InputABI: strippedABI, + InputBin: strings.TrimSpace(bytecodes[i]), + Constructor: evmABI.Constructor, + Calls: calls, + Transacts: transacts, } - args = append(args, fmt.Sprintf("%s %s", param, bindType(arg.Type))) } - returns, _ := bindReturn(prologue, name, method.Outputs) - - // Generate the docs to help with coding against the binding - callTypeDoc := "free data retrieval call" - if !method.Const { - callTypeDoc = "paid mutator transaction" + // Generate the contract template data content and render it + data := &tmplData{ + Package: pkg, + Contracts: contracts, } - docs := fmt.Sprintf("// %s is a %s binding the contract method 0x%x.\n", name, callTypeDoc, method.Id()) - docs += fmt.Sprintf("// \n") - docs += fmt.Sprintf("// Solidity: %s", strings.TrimPrefix(method.String(), "function ")) + buffer := new(bytes.Buffer) - // Generate the passthrough argument list for sessions - params := make([]string, len(args)) - for i, param := range args { - params[i] = strings.Split(param, " ")[0] + funcs := map[string]interface{}{ + "bindtype": bindType, } - sessargs := "" - if len(params) > 0 { - sessargs = "," + strings.Join(params, ",") + tmpl := template.Must(template.New("").Funcs(funcs).Parse(tmplSource)) + if err := tmpl.Execute(buffer, data); err != nil { + return "", err } - // Generate the method itself for both the read/write version and the combo too - code := fmt.Sprintf("%s\n", prologue) - if method.Const { - // Create the main call implementation - callargs := append([]string{"opts *bind.CallOpts"}, args...) - - code += fmt.Sprintf("%s\n", docs) - code += fmt.Sprintf("func (_%s *%sCaller) %s(%s) (%s) {\n", kind, kind, name, strings.Join(callargs, ","), strings.Join(returns, ",")) - code += fmt.Sprintf(" %s\n", bindCallBody(kind, method.Name, callargs, returns)) - code += fmt.Sprintf("}\n\n") - - // Create the wrapping session call implementation - code += fmt.Sprintf("%s\n", docs) - code += fmt.Sprintf("func (_%s *%sSession) %s(%s) (%s) {\n", kind, kind, name, strings.Join(args, ","), strings.Join(returns, ",")) - code += fmt.Sprintf(" return _%s.Contract.%s(&_%s.CallOpts %s)\n", kind, name, kind, sessargs) - code += fmt.Sprintf("}\n\n") - - code += fmt.Sprintf("%s\n", docs) - code += fmt.Sprintf("func (_%s *%sCallerSession) %s(%s) (%s) {\n", kind, kind, name, strings.Join(args, ","), strings.Join(returns, ",")) - code += fmt.Sprintf(" return _%s.Contract.%s(&_%s.CallOpts %s)\n", kind, name, kind, sessargs) - code += fmt.Sprintf("}\n\n") - } else { - // Create the main transaction implementation - txargs := append([]string{"opts *bind.TransactOpts"}, args...) - - code += fmt.Sprintf("%s\n", docs) - code += fmt.Sprintf("func (_%s *%sTransactor) %s(%s) (*types.Transaction, error) {\n", kind, kind, name, strings.Join(txargs, ",")) - code += fmt.Sprintf(" %s\n", bindTransactionBody(kind, method.Name, txargs)) - code += fmt.Sprintf("}\n\n") - - // Create the wrapping session call implementation - code += fmt.Sprintf("%s\n", docs) - code += fmt.Sprintf("func (_%s *%sSession) %s(%s) (*types.Transaction, error) {\n", kind, kind, name, strings.Join(args, ",")) - code += fmt.Sprintf(" return _%s.Contract.%s(&_%s.TransactOpts %s)\n", kind, name, kind, sessargs) - code += fmt.Sprintf("}\n\n") - - code += fmt.Sprintf("%s\n", docs) - code += fmt.Sprintf("func (_%s *%sTransactorSession) %s(%s) (*types.Transaction, error) {\n", kind, kind, name, strings.Join(args, ",")) - code += fmt.Sprintf(" return _%s.Contract.%s(&_%s.TransactOpts %s)\n", kind, name, kind, sessargs) - code += fmt.Sprintf("}\n\n") + // Pass the code through goimports to clean it up and double check + code, err := imports.Process("", buffer.Bytes(), nil) + if err != nil { + return "", fmt.Errorf("%v\n%s", err, buffer) } - return code + return string(code), nil } // bindType converts a Solidity type to a Go one. Since there is no clear mapping @@ -319,102 +153,21 @@ func bindType(kind abi.Type) string { } } -// bindReturn creates the list of return parameters for a method invocation. If -// all the fields of the return type are named, and there is more than one value -// being returned, the returns are wrapped in a result struct. -func bindReturn(prologue *bytes.Buffer, method string, outputs []abi.Argument) ([]string, string) { - // Generate the anonymous return list for when a struct is not needed/possible - var ( - returns = make([]string, 0, len(outputs)+1) - anonymous = false - ) - for _, ret := range outputs { - returns = append(returns, bindType(ret.Type)) - if ret.Name == "" { - anonymous = true - } - } - if anonymous || len(returns) < 2 { - returns = append(returns, "error") - return returns, "" - } - // If the returns are named and numerous, wrap in a result struct - wrapper, impl := bindReturnStruct(method, outputs) - prologue.WriteString(impl + "\n") - return []string{"*" + wrapper, "error"}, wrapper +// capitalise makes the first character of a string upper case. +func capitalise(input string) string { + return strings.ToUpper(input[:1]) + input[1:] } -// bindReturnStruct creates a Go structure with the specified fields to be used -// as the return type from a method call. -func bindReturnStruct(method string, returns []abi.Argument) (string, string) { - fields := make([]string, 0, len(returns)) - for _, ret := range returns { - fields = append(fields, fmt.Sprintf("%s %s", strings.ToUpper(ret.Name[:1])+ret.Name[1:], bindType(ret.Type))) +// structured checks whether a method has enough information to return a proper +// Go struct ot if flat returns are needed. +func structured(method abi.Method) bool { + if len(method.Outputs) < 2 { + return false } - kind := fmt.Sprintf("%sResult", method) - docs := fmt.Sprintf("// %s is the result of the %s invocation.", kind, method) - - return kind, fmt.Sprintf("%s\ntype %s struct {\n%s\n}", docs, kind, strings.Join(fields, "\n")) -} - -// bindCallBody creates the Go code to declare a batch of return values, invoke -// an Ethereum method call with the requested parameters, parse the binary output -// into the return values and return them. -func bindCallBody(kind string, method string, params []string, returns []string) string { - body := "" - - // Allocate memory for each of the return values - rets := make([]string, 0, len(returns)-1) - if len(returns) > 1 { - body += "var (" - for i, kind := range returns[:len(returns)-1] { // Omit the final error - name := fmt.Sprintf("ret%d", i) - - rets = append(rets, name) - body += fmt.Sprintf("%s = new(%s)\n", name, kind) + for _, out := range method.Outputs { + if out.Name == "" { + return false } - body += ")\n" - } - // Assemble a single collector variable for the result ABI initialization - result := strings.Join(rets, ",") - if len(returns) > 2 { - result = "[]interface{}{" + result + "}" - } - // Extract the parameter list into a flat variable name list - inputs := make([]string, len(params)-1) // Omit the call options - for i, param := range params[1:] { - inputs[i] = strings.Split(param, " ")[0] - } - input := "" - if len(inputs) > 0 { - input = "," + strings.Join(inputs, ",") - } - // Request executing the contract call and return the results with the errors - body += fmt.Sprintf("err := _%s.contract.Call(opts, %s, \"%s\" %s)\n", kind, result, method, input) - - outs := make([]string, 0, len(returns)) - for _, ret := range rets { // Handle th final error separately - outs = append(outs, "*"+ret) - } - outs = append(outs, "err") - - body += fmt.Sprintf("return %s", strings.Join(outs, ",")) - - return body -} - -// bindTransactionBody creates the Go code to invoke an Ethereum transaction call -// with the requested parameters, and return the assembled transaction object. -func bindTransactionBody(kind string, method string, params []string) string { - // Extract the parameter list into a flat variable name list - inputs := make([]string, len(params)-1) // Omit the auth options - for i, param := range params[1:] { - inputs[i] = strings.Split(param, " ")[0] - } - input := "" - if len(inputs) > 0 { - input = "," + strings.Join(inputs, ",") } - // Request executing the contract call and return the results with the errors - return fmt.Sprintf("return _%s.contract.Transact(opts, \"%s\" %s)", kind, method, input) + return true } diff --git a/accounts/abi/bind/bind_test.go b/accounts/abi/bind/bind_test.go index a86d39db7..c6ed7a630 100644 --- a/accounts/abi/bind/bind_test.go +++ b/accounts/abi/bind/bind_test.go @@ -43,15 +43,17 @@ var bindTests = []struct { `contract NilContract {}`, `606060405260068060106000396000f3606060405200`, `[]`, - `if b, err := NewEmpty(common.Address{}, backends.NewNilBackend()); b == nil || err != nil { - t.Fatalf("combined binding (%v) nil or error (%v) not nil", b, nil) - } - if b, err := NewEmptyCaller(common.Address{}, backends.NewNilBackend()); b == nil || err != nil { - t.Fatalf("caller binding (%v) nil or error (%v) not nil", b, nil) - } - if b, err := NewEmptyTransactor(common.Address{}, backends.NewNilBackend()); b == nil || err != nil { - t.Fatalf("transactor binding (%v) nil or error (%v) not nil", b, nil) - }`, + ` + if b, err := NewEmpty(common.Address{}, backends.NewNilBackend()); b == nil || err != nil { + t.Fatalf("combined binding (%v) nil or error (%v) not nil", b, nil) + } + if b, err := NewEmptyCaller(common.Address{}, backends.NewNilBackend()); b == nil || err != nil { + t.Fatalf("caller binding (%v) nil or error (%v) not nil", b, nil) + } + if b, err := NewEmptyTransactor(common.Address{}, backends.NewNilBackend()); b == nil || err != nil { + t.Fatalf("transactor binding (%v) nil or error (%v) not nil", b, nil) + } + `, }, // Test that all the official sample contracts bind correctly { @@ -59,28 +61,141 @@ var bindTests = []struct { `https://ethereum.org/token`, `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`, `[{"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"}]`, - `if b, err := NewToken(common.Address{}, backends.NewNilBackend()); b == nil || err != nil { - t.Fatalf("binding (%v) nil or error (%v) not nil", b, nil) - }`, + ` + if b, err := NewToken(common.Address{}, backends.NewNilBackend()); b == nil || err != nil { + t.Fatalf("binding (%v) nil or error (%v) not nil", b, nil) + } + `, }, { `Crowdsale`, `https://ethereum.org/crowdsale`, `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`, `[{"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"}]`, - `if b, err := NewCrowdsale(common.Address{}, backends.NewNilBackend()); b == nil || err != nil { - t.Fatalf("binding (%v) nil or error (%v) not nil", b, nil) - }`, + ` + if b, err := NewCrowdsale(common.Address{}, backends.NewNilBackend()); b == nil || err != nil { + t.Fatalf("binding (%v) nil or error (%v) not nil", b, nil) + } + `, }, { `DAO`, `https://ethereum.org/dao`, `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`, `[{"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"}]`, - `if b, err := NewDAO(common.Address{}, backends.NewNilBackend()); b == nil || err != nil { + ` + if b, err := NewDAO(common.Address{}, backends.NewNilBackend()); b == nil || err != nil { + t.Fatalf("binding (%v) nil or error (%v) not nil", b, nil) + } + `, + }, + // Test that named and anonymous inputs are handled correctly + { + `InputChecker`, ``, ``, + ` + [ + {"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":[]} + ] + `, + `if b, err := NewInputChecker(common.Address{}, backends.NewNilBackend()); 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) }`, }, + // Test that named and anonymous outputs are handled correctly + { + `OutputChecker`, ``, ``, + ` + [ + {"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":"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"}]} + ] + `, + `if b, err := NewOutputChecker(common.Address{}, backends.NewNilBackend()); 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.AnonOutputs(nil) + str1, str2, err = b.MixedOutputs(nil) + + fmt.Println(str1, str2, res.Str1, res.Str2, err) + }`, + }, + // 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; + } + } + `, + `6060604052604051610328380380610328833981016040528051018060006000509080519060200190828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f10608d57805160ff19168380011785555b50607c9291505b8082111560ba57838155600101606b565b50505061026a806100be6000396000f35b828001600101855582156064579182015b828111156064578251826000505591602001919060010190609e565b509056606060405260e060020a60003504630d86a0e181146100315780636874e8091461008d578063d736c513146100ea575b005b610190600180546020600282841615610100026000190190921691909104601f810182900490910260809081016040526060828152929190828280156102295780601f106101fe57610100808354040283529160200191610229565b61019060008054602060026001831615610100026000190190921691909104601f810182900490910260809081016040526060828152929190828280156102295780601f106101fe57610100808354040283529160200191610229565b60206004803580820135601f81018490049093026080908101604052606084815261002f946024939192918401918190838280828437509496505050505050508060016000509080519060200190828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f1061023157805160ff19168380011785555b506102619291505b808211156102665760008155830161017d565b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600f02600301f150905090810190601f1680156101f05780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b820191906000526020600020905b81548152906001019060200180831161020c57829003601f168201915b505050505081565b82800160010185558215610175579182015b82811115610175578251826000505591602001919060010190610243565b505050565b509056`, + `[{"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"}]`, + ` + // Generate a new random account and a funded simulator + key := crypto.NewKey(rand.Reader) + sim := backends.NewSimulatedBackend(core.GenesisAccount{Address: key.Address, Balance: big.NewInt(10000000000)}) + + // Convert the tester key to an authorized transactor for ease of use + auth := bind.NewKeyedTransactor(key) + + // 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) + } + `, + }, } // Tests that packages generated by the binder can be successfully compiled and @@ -110,15 +225,15 @@ func TestBindings(t *testing.T) { defer os.RemoveAll(ws) // Generate the binding and create a Go package in the workspace - bind, err := Bind(tt.abi, tt.bytecode, "bindtest", tt.name) + bind, err := Bind([]string{tt.name}, []string{tt.abi}, []string{tt.bytecode}, "bindtest") if err != nil { t.Fatalf("test %d: failed to generate binding: %v", i, err) } pkg := filepath.Join(ws, "bindtest") - if err := os.MkdirAll(pkg, 0700); err != nil { + if err = os.MkdirAll(pkg, 0700); err != nil { t.Fatalf("test %d: failed to create package: %v", i, err) } - if err := ioutil.WriteFile(filepath.Join(pkg, "main.go"), []byte(bind), 0600); err != nil { + if err = ioutil.WriteFile(filepath.Join(pkg, "main.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 @@ -134,7 +249,7 @@ func TestBindings(t *testing.T) { cmd := exec.Command(gocmd, "test", "-v") cmd.Dir = pkg if out, err := cmd.CombinedOutput(); err != nil { - t.Fatalf("test %d: failed to run binding test: %v\n%s", i, err, out) + t.Fatalf("test %d: failed to run binding test: %v\n%s\n%s", i, err, out, bind) } } } diff --git a/accounts/abi/bind/template.go b/accounts/abi/bind/template.go new file mode 100644 index 000000000..5e160d203 --- /dev/null +++ b/accounts/abi/bind/template.go @@ -0,0 +1,212 @@ +// 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 +} + +// 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 denetare deploy code from + 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 +} + +// 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 contract +} + +// tmplSource is the Go source template use to generate the contract binding +// based on. +const tmplSource = ` +// This file is an automatically generated Go binding. Do not modify as any +// change will likely be lost upon the next re-generation! + +package {{.Package}} + +{{range $contract := .Contracts}} + // {{.Type}}ABI is the input ABI used to generate the binding from. + const {{.Type}}ABI = ` + "`" + `{{.InputABI}}` + "`" + ` + + {{if .InputBin}} + // {{.Type}}Bin is the compiled bytecode used for deploying new contracts. + const {{.Type}}Bin = ` + "`" + `{{.InputBin}}` + "`" + ` + + // 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}}{{end}}) (common.Address, *types.Transaction, *{{.Type}}, error) { + parsed, err := abi.JSON(strings.NewReader({{.Type}}ABI)) + if err != nil { + return common.Address{}, nil, nil, err + } + 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} }, 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}}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}}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 + } + + // 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.(bind.ContractCaller), backend.(bind.ContractTransactor)) + if err != nil { + return nil, err + } + return &{{.Type}}{ {{.Type}}Caller: {{.Type}}Caller{contract: contract}, {{.Type}}Transactor: {{.Type}}Transactor{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) + 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) + if err != nil { + return nil, err + } + return &{{.Type}}Transactor{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) (*bind.BoundContract, error) { + parsed, err := abi.JSON(strings.NewReader({{.Type}}ABI)) + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, parsed, caller, transactor), nil + } + + {{range .Calls}} + {{if .Structured}} + // {{.Normalized.Name}}Result is the result of the {{.Normalized.Name}} invocation." + type {{.Normalized.Name}}Result struct { + {{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type}} + {{end}} + } + {{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}}Caller) {{.Normalized.Name}}(opts *bind.CallOpts {{range .Normalized.Inputs}}, {{.Name}} {{bindtype .Type}} {{end}}) ({{if .Structured}}*{{.Normalized.Name}}Result,{{else}}{{range .Normalized.Outputs}}{{bindtype .Type}},{{end}}{{end}} error) { + var ( + {{if .Structured}}ret = new(*{{.Normalized.Name}}Result){{else}}{{range $i, $_ := .Normalized.Outputs}}ret{{$i}} = new({{bindtype .Type}}) + {{end}}{{end}} + ) + out := {{if .Structured}}ret{{else}}{{if eq (len .Normalized.Outputs) 1}}ret0{{else}}[]interface{}{ + {{range $i, $_ := .Normalized.Outputs}}ret{{$i}}, + {{end}} + }{{end}}{{end}} + err := _{{$contract.Type}}.contract.Call(opts, out, "{{.Original.Name}}" {{range .Normalized.Inputs}}, {{.Name}}{{end}}) + return {{if .Structured}}*ret,{{else}}{{range $i, $_ := .Normalized.Outputs}}*ret{{$i}},{{end}}{{end}} err + } + + // {{.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}} {{end}}) ({{if .Structured}}*{{.Normalized.Name}}Result, {{else}} {{range .Normalized.Outputs}}{{bindtype .Type}},{{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}} {{end}}) ({{if .Structured}}*{{.Normalized.Name}}Result, {{else}} {{range .Normalized.Outputs}}{{bindtype .Type}},{{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}} {{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}} {{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}} {{end}}) (*types.Transaction, error) { + return _{{$contract.Type}}.Contract.{{.Normalized.Name}}(&_{{$contract.Type}}.TransactOpts {{range $i, $_ := .Normalized.Inputs}}, {{.Name}}{{end}}) + } + {{end}} +{{end}} +` -- cgit v1.2.3