accounts/abi/bind: add utilities for waiting on transactions

The need for these functions comes up in code that actually deploys and
uses contracts. As of this commit, they can be used with both
SimulatedBackend and ethclient.

SimulatedBackend gains some additional methods in the process and is now
safe for concurrent use.

accounts/abi/bind/backend.go

@@ -35,6 +35,10 @@ var (
 	// This error is raised when attempting to perform a pending state action
 	// on a backend that doesn't implement PendingContractCaller.
 	ErrNoPendingState = errors.New("backend does not support pending state")
+
+	// This error is returned by WaitDeployed if contract creation leaves an
+	// empty contract behind.
+	ErrNoCodeAfterDeploy = errors.New("no contract code after deployment")
 )
 
 // ContractCaller defines the methods needed to allow operating with contract on a read
@@ -48,6 +52,12 @@ type ContractCaller interface {
 	CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error)
 }
 
+// DeployBackend wraps the operations needed by WaitMined and WaitDeployed.
+type DeployBackend interface {
+	TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error)
+	CodeAt(ctx context.Context, account common.Address, blockNumber *big.Int) ([]byte, error)
+}
+
 // PendingContractCaller defines methods to perform contract calls on the pending state.
 // Call will try to discover this interface when access to the pending state is requested.
 // If the backend does not support the pending state, Call returns ErrNoPendingState.

accounts/abi/bind/backends/simulated.go

@@ -17,8 +17,10 @@
 package backends
 
 import (
+	"errors"
 	"fmt"
 	"math/big"
+	"sync"
 
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
@@ -38,12 +40,15 @@ var chainConfig = &core.ChainConfig{HomesteadBlock: big.NewInt(0)}
 // This nil assignment ensures compile time that SimulatedBackend implements bind.ContractBackend.
 var _ bind.ContractBackend = (*SimulatedBackend)(nil)
 
+var errBlockNumberUnsupported = errors.New("SimulatedBackend cannot access blocks other than the latest block")
+
 // 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
 
+	mu           sync.Mutex
 	pendingBlock *types.Block   // Currently pending block that will be imported on request
 	pendingState *state.StateDB // Currently pending state that will be the active on on request
 }
@@ -54,53 +59,109 @@ func NewSimulatedBackend(accounts ...core.GenesisAccount) *SimulatedBackend {
 	database, _ := ethdb.NewMemDatabase()
 	core.WriteGenesisBlockForTesting(database, accounts...)
 	blockchain, _ := core.NewBlockChain(database, chainConfig, new(core.FakePow), new(event.TypeMux))
-
-	backend := &SimulatedBackend{
-		database:   database,
-		blockchain: blockchain,
-	}
-	backend.Rollback()
-
+	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() {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
 	if _, err := b.blockchain.InsertChain([]*types.Block{b.pendingBlock}); err != nil {
 		panic(err) // This cannot happen unless the simulator is wrong, fail in that case
 	}
-	b.Rollback()
+	b.rollback()
 }
 
 // Rollback aborts all pending transactions, reverting to the last committed state.
 func (b *SimulatedBackend) Rollback() {
-	blocks, _ := core.GenerateChain(nil, b.blockchain.CurrentBlock(), b.database, 1, func(int, *core.BlockGen) {})
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	b.rollback()
+}
 
+func (b *SimulatedBackend) rollback() {
+	blocks, _ := core.GenerateChain(nil, b.blockchain.CurrentBlock(), b.database, 1, func(int, *core.BlockGen) {})
 	b.pendingBlock = blocks[0]
 	b.pendingState, _ = state.New(b.pendingBlock.Root(), b.database)
 }
 
-// CodeAt implements ChainStateReader.CodeAt, returning the code associated with
-// a certain account at a given block number in the blockchain.
+// CodeAt returns the code associated with a certain account in the blockchain.
 func (b *SimulatedBackend) CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
 	if blockNumber != nil && blockNumber.Cmp(b.blockchain.CurrentBlock().Number()) != 0 {
-		return nil, fmt.Errorf("SimulatedBackend cannot access blocks other than the latest block")
+		return nil, errBlockNumberUnsupported
 	}
 	statedb, _ := b.blockchain.State()
 	return statedb.GetCode(contract), nil
 }
 
-// PendingCodeAt implements PendingStateReader.PendingCodeAt, returning the
-// code associated with a certain account in the pending state of the blockchain.
+// BalanceAt returns the wei balance of a certain account in the blockchain.
+func (b *SimulatedBackend) BalanceAt(ctx context.Context, contract common.Address, blockNumber *big.Int) (*big.Int, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	if blockNumber != nil && blockNumber.Cmp(b.blockchain.CurrentBlock().Number()) != 0 {
+		return nil, errBlockNumberUnsupported
+	}
+	statedb, _ := b.blockchain.State()
+	return statedb.GetBalance(contract), nil
+}
+
+// NonceAt returns the nonce of a certain account in the blockchain.
+func (b *SimulatedBackend) NonceAt(ctx context.Context, contract common.Address, blockNumber *big.Int) (uint64, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	if blockNumber != nil && blockNumber.Cmp(b.blockchain.CurrentBlock().Number()) != 0 {
+		return 0, errBlockNumberUnsupported
+	}
+	statedb, _ := b.blockchain.State()
+	return statedb.GetNonce(contract), nil
+}
+
+// StorageAt returns the value of key in the storage of an account in the blockchain.
+func (b *SimulatedBackend) StorageAt(ctx context.Context, contract common.Address, key common.Hash, blockNumber *big.Int) ([]byte, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	if blockNumber != nil && blockNumber.Cmp(b.blockchain.CurrentBlock().Number()) != 0 {
+		return nil, errBlockNumberUnsupported
+	}
+	statedb, _ := b.blockchain.State()
+	if obj := statedb.GetStateObject(contract); obj != nil {
+		val := obj.GetState(key)
+		return val[:], nil
+	}
+	return nil, nil
+}
+
+// TransactionReceipt returns the receipt of a transaction.
+func (b *SimulatedBackend) TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error) {
+	return core.GetReceipt(b.database, txHash), nil
+}
+
+// PendingCodeAt returns the code associated with an account in the pending state.
 func (b *SimulatedBackend) PendingCodeAt(ctx context.Context, contract common.Address) ([]byte, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
 	return b.pendingState.GetCode(contract), nil
 }
 
 // CallContract executes a contract call.
 func (b *SimulatedBackend) CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
 	if blockNumber != nil && blockNumber.Cmp(b.blockchain.CurrentBlock().Number()) != 0 {
-		return nil, fmt.Errorf("SimulatedBackend cannot access blocks other than the latest block")
+		return nil, errBlockNumberUnsupported
 	}
 	state, err := b.blockchain.State()
 	if err != nil {
@@ -112,6 +173,9 @@ func (b *SimulatedBackend) CallContract(ctx context.Context, call ethereum.CallM
 
 // PendingCallContract executes a contract call on the pending state.
 func (b *SimulatedBackend) PendingCallContract(ctx context.Context, call ethereum.CallMsg) ([]byte, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
 	rval, _, err := b.callContract(ctx, call, b.pendingBlock, b.pendingState.Copy())
 	return rval, err
 }
@@ -119,6 +183,9 @@ func (b *SimulatedBackend) PendingCallContract(ctx context.Context, call ethereu
 // PendingNonceAt implements PendingStateReader.PendingNonceAt, retrieving
 // the nonce currently pending for the account.
 func (b *SimulatedBackend) PendingNonceAt(ctx context.Context, account common.Address) (uint64, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
 	return b.pendingState.GetOrNewStateObject(account).Nonce(), nil
 }
 
@@ -131,6 +198,9 @@ func (b *SimulatedBackend) SuggestGasPrice(ctx context.Context) (*big.Int, error
 // EstimateGas executes the requested code against the currently pending block/state and
 // returns the used amount of gas.
 func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMsg) (*big.Int, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
 	_, gas, err := b.callContract(ctx, call, b.pendingBlock, b.pendingState.Copy())
 	return gas, err
 }
@@ -162,6 +232,9 @@ func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallM
 // SendTransaction updates the pending block to include the given transaction.
 // It panics if the transaction is invalid.
 func (b *SimulatedBackend) SendTransaction(ctx context.Context, tx *types.Transaction) error {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
 	sender, err := tx.From()
 	if err != nil {
 		panic(fmt.Errorf("invalid transaction: %v", err))

accounts/abi/bind/util.go

@@ -0,0 +1,76 @@
+// 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 (
+	"fmt"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/logger/glog"
+	"golang.org/x/net/context"
+)
+
+// WaitMined waits for tx to be mined on the blockchain.
+// It stops waiting when the context is canceled.
+func WaitMined(ctx context.Context, b DeployBackend, tx *types.Transaction) (*types.Receipt, error) {
+	queryTicker := time.NewTicker(1 * time.Second)
+	defer queryTicker.Stop()
+	loghash := tx.Hash().Hex()[:8]
+	for {
+		receipt, err := b.TransactionReceipt(ctx, tx.Hash())
+		if receipt != nil {
+			return receipt, nil
+		}
+		if err != nil {
+			glog.V(logger.Detail).Infof("tx %x error: %v", loghash, err)
+		} else {
+			glog.V(logger.Detail).Infof("tx %x not yet mined...", loghash)
+		}
+		// Wait for the next round.
+		select {
+		case <-ctx.Done():
+			return nil, ctx.Err()
+		case <-queryTicker.C:
+		}
+	}
+}
+
+// WaitDeployed waits for a contract deployment transaction and returns the on-chain
+// contract address when it is mined. It stops waiting when ctx is canceled.
+func WaitDeployed(ctx context.Context, b DeployBackend, tx *types.Transaction) (common.Address, error) {
+	if tx.To() != nil {
+		return common.Address{}, fmt.Errorf("tx is not contract creation")
+	}
+	receipt, err := WaitMined(ctx, b, tx)
+	if err != nil {
+		return common.Address{}, err
+	}
+	if receipt.ContractAddress == (common.Address{}) {
+		return common.Address{}, fmt.Errorf("zero address")
+	}
+	// Check that code has indeed been deployed at the address.
+	// This matters on pre-Homestead chains: OOG in the constructor
+	// could leave an empty account behind.
+	code, err := b.CodeAt(ctx, receipt.ContractAddress, nil)
+	if err == nil && len(code) == 0 {
+		err = ErrNoCodeAfterDeploy
+	}
+	return receipt.ContractAddress, err
+}

accounts/abi/bind/util_test.go

@@ -0,0 +1,93 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package bind_test
+
+import (
+	"math/big"
+	"testing"
+	"time"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto"
+	"golang.org/x/net/context"
+)
+
+var testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
+
+var waitDeployedTests = map[string]struct {
+	code        string
+	gas         *big.Int
+	wantAddress common.Address
+	wantErr     error
+}{
+	"successful deploy": {
+		code:        `6060604052600a8060106000396000f360606040526008565b00`,
+		gas:         big.NewInt(3000000),
+		wantAddress: common.HexToAddress("0x3a220f351252089d385b29beca14e27f204c296a"),
+	},
+	"empty code": {
+		code:        ``,
+		gas:         big.NewInt(300000),
+		wantErr:     bind.ErrNoCodeAfterDeploy,
+		wantAddress: common.HexToAddress("0x3a220f351252089d385b29beca14e27f204c296a"),
+	},
+}
+
+func TestWaitDeployed(t *testing.T) {
+	for name, test := range waitDeployedTests {
+		backend := backends.NewSimulatedBackend(core.GenesisAccount{
+			Address: crypto.PubkeyToAddress(testKey.PublicKey),
+			Balance: big.NewInt(10000000000),
+		})
+
+		// Create the transaction.
+		tx := types.NewContractCreation(0, big.NewInt(0), test.gas, big.NewInt(1), common.FromHex(test.code))
+		tx, _ = tx.SignECDSA(testKey)
+
+		// Wait for it to get mined in the background.
+		var (
+			err     error
+			address common.Address
+			mined   = make(chan struct{})
+			ctx     = context.Background()
+		)
+		go func() {
+			address, err = bind.WaitDeployed(ctx, backend, tx)
+			close(mined)
+		}()
+
+		// Send and mine the transaction.
+		backend.SendTransaction(ctx, tx)
+		backend.Commit()
+
+		select {
+		case <-mined:
+			if err != test.wantErr {
+				t.Errorf("test %q: error mismatch: got %q, want %q", name, err, test.wantErr)
+			}
+			if address != test.wantAddress {
+				t.Errorf("test %q: unexpected contract address %s", name, address.Hex())
+			}
+		case <-time.After(2 * time.Second):
+			t.Errorf("test %q: timeout", name)
+		}
+	}
+}