aboutsummaryrefslogtreecommitdiffstats
path: root/accounts/abi/bind
diff options
context:
space:
mode:
Diffstat (limited to 'accounts/abi/bind')
-rw-r--r--accounts/abi/bind/auth.go53
-rw-r--r--accounts/abi/bind/backend.go196
-rw-r--r--accounts/abi/bind/backends/nil.go46
-rw-r--r--accounts/abi/bind/backends/remote.go202
-rw-r--r--accounts/abi/bind/backends/simulated.go184
-rw-r--r--accounts/abi/bind/base.go66
-rw-r--r--accounts/abi/bind/bind.go177
-rw-r--r--accounts/abi/bind/bind_test.go16
8 files changed, 696 insertions, 244 deletions
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 <http://www.gnu.org/licenses/>.
+
+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 <http://www.gnu.org/licenses/>.
+
+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 <http://www.gnu.org/licenses/>.
+
+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 <http://www.gnu.org/licenses/>.
+
+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`,
`606060405260405160808061145f833960e06040529051905160a05160c05160008054600160a060020a03191633179055600184815560028490556003839055600780549182018082558280158290116100b8576003028160030283600052602060002091820191016100b891906101c8565b50506060919091015160029190910155600160a060020a0381166000146100a65760008054600160a060020a031916821790555b505050506111f18061026e6000396000f35b505060408051608081018252600080825260208281018290528351908101845281815292820192909252426060820152600780549194509250811015610002579081527fa66cc928b5edb82af9bd49922954155ab7b0942694bea4ce44661d9a8736c6889050815181546020848101517401000000000000000000000000000000000000000002600160a060020a03199290921690921760a060020a60ff021916178255604083015180516001848101805460008281528690209195600293821615610100026000190190911692909204601f9081018390048201949192919091019083901061023e57805160ff19168380011785555b50610072929150610226565b5050600060028201556001015b8082111561023a578054600160a860020a031916815560018181018054600080835592600290821615610100026000190190911604601f81901061020c57506101bb565b601f0160209004906000526020600020908101906101bb91905b8082111561023a5760008155600101610226565b5090565b828001600101855582156101af579182015b828111156101af57825182600050559160200191906001019061025056606060405236156100b95760e060020a6000350463013cf08b81146100bb578063237e9492146101285780633910682114610281578063400e3949146102995780635daf08ca146102a257806369bd34361461032f5780638160f0b5146103385780638da5cb5b146103415780639644fcbd14610353578063aa02a90f146103be578063b1050da5146103c7578063bcca1fd3146104b5578063d3c0715b146104dc578063eceb29451461058d578063f2fde38b1461067b575b005b61069c6004356004805482908110156100025790600052602060002090600a02016000506005810154815460018301546003840154600485015460068601546007870154600160a060020a03959095169750929560020194919360ff828116946101009093041692919089565b60408051602060248035600481810135601f81018590048502860185019096528585526107759581359591946044949293909201918190840183828082843750949650505050505050600060006004600050848154811015610002575090527f8a35acfbc15ff81a39ae7d344fd709f28e8600b4aa8c65c6b64bfe7fe36bd19e600a8402908101547f8a35acfbc15ff81a39ae7d344fd709f28e8600b4aa8c65c6b64bfe7fe36bd19b909101904210806101e65750600481015460ff165b8061026757508060000160009054906101000a9004600160a060020a03168160010160005054846040518084600160a060020a0316606060020a0281526014018381526020018280519060200190808383829060006004602084601f0104600f02600301f15090500193505050506040518091039020816007016000505414155b8061027757506001546005820154105b1561109257610002565b61077560043560066020526000908152604090205481565b61077560055481565b61078760043560078054829081101561000257506000526003026000805160206111d18339815191528101547fa66cc928b5edb82af9bd49922954155ab7b0942694bea4ce44661d9a8736c68a820154600160a060020a0382169260a060020a90920460ff16917fa66cc928b5edb82af9bd49922954155ab7b0942694bea4ce44661d9a8736c689019084565b61077560025481565b61077560015481565b610830600054600160a060020a031681565b604080516020604435600481810135601f81018490048402850184019095528484526100b9948135946024803595939460649492939101918190840183828082843750949650505050505050600080548190600160a060020a03908116339091161461084d57610002565b61077560035481565b604080516020604435600481810135601f8101849004840285018401909552848452610775948135946024803595939460649492939101918190840183828082843750506040805160209735808a0135601f81018a90048a0283018a019093528282529698976084979196506024909101945090925082915084018382808284375094965050505050505033600160a060020a031660009081526006602052604081205481908114806104ab5750604081205460078054909190811015610002579082526003026000805160206111d1833981519152015460a060020a900460ff16155b15610ce557610002565b6100b960043560243560443560005433600160a060020a03908116911614610b1857610002565b604080516020604435600481810135601f810184900484028501840190955284845261077594813594602480359593946064949293910191819084018382808284375094965050505050505033600160a060020a031660009081526006602052604081205481908114806105835750604081205460078054909190811015610002579082526003026000805160206111d18339815191520181505460a060020a900460ff16155b15610f1d57610002565b604080516020606435600481810135601f81018490048402850184019095528484526107759481359460248035956044359560849492019190819084018382808284375094965050505050505060006000600460005086815481101561000257908252600a027f8a35acfbc15ff81a39ae7d344fd709f28e8600b4aa8c65c6b64bfe7fe36bd19b01815090508484846040518084600160a060020a0316606060020a0281526014018381526020018280519060200190808383829060006004602084601f0104600f02600301f150905001935050505060405180910390208160070160005054149150610cdc565b6100b960043560005433600160a060020a03908116911614610f0857610002565b604051808a600160a060020a031681526020018981526020018060200188815260200187815260200186815260200185815260200184815260200183815260200182810382528981815460018160011615610100020316600290048152602001915080546001816001161561010002031660029004801561075e5780601f106107335761010080835404028352916020019161075e565b820191906000526020600020905b81548152906001019060200180831161074157829003601f168201915b50509a505050505050505050505060405180910390f35b60408051918252519081900360200190f35b60408051600160a060020a038616815260208101859052606081018390526080918101828152845460026001821615610100026000190190911604928201839052909160a08301908590801561081e5780601f106107f35761010080835404028352916020019161081e565b820191906000526020600020905b81548152906001019060200180831161080157829003601f168201915b50509550505050505060405180910390f35b60408051600160a060020a03929092168252519081900360200190f35b600160a060020a03851660009081526006602052604081205414156108a957604060002060078054918290556001820180825582801582901161095c5760030281600302836000526020600020918201910161095c9190610a4f565b600160a060020a03851660009081526006602052604090205460078054919350908390811015610002575060005250600381026000805160206111d183398151915201805474ff0000000000000000000000000000000000000000191660a060020a85021781555b60408051600160a060020a03871681526020810186905281517f27b022af4a8347100c7a041ce5ccf8e14d644ff05de696315196faae8cd50c9b929181900390910190a15050505050565b505050915081506080604051908101604052808681526020018581526020018481526020014281526020015060076000508381548110156100025790600052602060002090600302016000508151815460208481015160a060020a02600160a060020a03199290921690921774ff00000000000000000000000000000000000000001916178255604083015180516001848101805460008281528690209195600293821615610100026000190190911692909204601f90810183900482019491929190910190839010610ad357805160ff19168380011785555b50610b03929150610abb565b5050600060028201556001015b80821115610acf57805474ffffffffffffffffffffffffffffffffffffffffff1916815560018181018054600080835592600290821615610100026000190190911604601f819010610aa15750610a42565b601f016020900490600052602060002090810190610a4291905b80821115610acf5760008155600101610abb565b5090565b82800160010185558215610a36579182015b82811115610a36578251826000505591602001919060010190610ae5565b50506060919091015160029190910155610911565b600183905560028290556003819055604080518481526020810184905280820183905290517fa439d3fa452be5e0e1e24a8145e715f4fd8b9c08c96a42fd82a855a85e5d57de9181900360600190a1505050565b50508585846040518084600160a060020a0316606060020a0281526014018381526020018280519060200190808383829060006004602084601f0104600f02600301f150905001935050505060405180910390208160070160005081905550600260005054603c024201816003016000508190555060008160040160006101000a81548160ff0219169083021790555060008160040160016101000a81548160ff02191690830217905550600081600501600050819055507f646fec02522b41e7125cfc859a64fd4f4cefd5dc3b6237ca0abe251ded1fa881828787876040518085815260200184600160a060020a03168152602001838152602001806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600f02600301f150905090810190601f168015610cc45780820380516001836020036101000a031916815260200191505b509550505050505060405180910390a1600182016005555b50949350505050565b6004805460018101808355909190828015829011610d1c57600a0281600a028360005260206000209182019101610d1c9190610db8565b505060048054929450918491508110156100025790600052602060002090600a02016000508054600160a060020a031916871781556001818101879055855160028381018054600082815260209081902096975091959481161561010002600019011691909104601f90810182900484019391890190839010610ed857805160ff19168380011785555b50610b6c929150610abb565b50506001015b80821115610acf578054600160a060020a03191681556000600182810182905560028381018054848255909281161561010002600019011604601f819010610e9c57505b5060006003830181905560048301805461ffff191690556005830181905560068301819055600783018190556008830180548282559082526020909120610db2916002028101905b80821115610acf57805474ffffffffffffffffffffffffffffffffffffffffff1916815560018181018054600080835592600290821615610100026000190190911604601f819010610eba57505b5050600101610e44565b601f016020900490600052602060002090810190610dfc9190610abb565b601f016020900490600052602060002090810190610e929190610abb565b82800160010185558215610da6579182015b82811115610da6578251826000505591602001919060010190610eea565b60008054600160a060020a0319168217905550565b600480548690811015610002576000918252600a027f8a35acfbc15ff81a39ae7d344fd709f28e8600b4aa8c65c6b64bfe7fe36bd19b01905033600160a060020a0316600090815260098201602052604090205490915060ff1660011415610f8457610002565b33600160a060020a031660009081526009820160205260409020805460ff1916600190811790915560058201805490910190558315610fcd576006810180546001019055610fda565b6006810180546000190190555b7fc34f869b7ff431b034b7b9aea9822dac189a685e0b015c7d1be3add3f89128e8858533866040518085815260200184815260200183600160a060020a03168152602001806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600f02600301f150905090810190601f16801561107a5780820380516001836020036101000a031916815260200191505b509550505050505060405180910390a1509392505050565b6006810154600354901315611158578060000160009054906101000a9004600160a060020a0316600160a060020a03168160010160005054670de0b6b3a76400000284604051808280519060200190808383829060006004602084601f0104600f02600301f150905090810190601f1680156111225780820380516001836020036101000a031916815260200191505b5091505060006040518083038185876185025a03f15050505060048101805460ff191660011761ff00191661010017905561116d565b60048101805460ff191660011761ff00191690555b60068101546005820154600483015460408051888152602081019490945283810192909252610100900460ff166060830152517fd220b7272a8b6d0d7d6bcdace67b936a8f175e6d5c1b3ee438b72256b32ab3af9181900360800190a1509291505056a66cc928b5edb82af9bd49922954155ab7b0942694bea4ce44661d9a8736c688`,
`[{"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)
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-27 02:24:27 +0800