Merge pull request #2357 from karalabe/abi-binding-generator

accounts/abi/bind: Go ABI binding generator

11 files changed, 1436 insertions, 60 deletions

diff --git a/accounts/abi/abi.go b/accounts/abi/abi.go
index 673088f60..91f9700d9 100644
--- a/accounts/abi/abi.go
+++ b/accounts/abi/abi.go
@@ -26,17 +26,13 @@ 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.
 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.
@@ -53,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
@@ -66,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
@@ -96,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
@@ -169,21 +168,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 +177,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 {
@@ -303,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/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/auth.go b/accounts/abi/bind/auth.go
new file mode 100644
index 000000000..624f995b0
--- /dev/null
+++ b/accounts/abi/bind/auth.go
@@ -0,0 +1,59 @@
+// 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"
+	"io"
+	"io/ioutil"
+
+	"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 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
+	}
+	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{
+		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")
+			}
+			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
new file mode 100644
index 000000000..328f9f3b7
--- /dev/null
+++ b/accounts/abi/bind/backend.go
@@ -0,0 +1,63 @@
+// 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 (
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+// 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. 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
+// 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.
+	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
+}
+
+// ContractBackend defines the methods needed to allow operating with contract
+// on a read-write basis.
+type ContractBackend interface {
+	ContractCaller
+	ContractTransactor
+}
diff --git a/accounts/abi/bind/backends/nil.go b/accounts/abi/bind/backends/nil.go
new file mode 100644
index 000000000..3b1e6dce7
--- /dev/null
+++ b/accounts/abi/bind/backends/nil.go
@@ -0,0 +1,49 @@
+// 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"
+)
+
+// 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.
+type nilBackend struct{}
+
+func (*nilBackend) ContractCall(common.Address, []byte, bool) ([]byte, error) {
+	panic("not implemented")
+}
+func (*nilBackend) EstimateGasLimit(common.Address, *common.Address, *big.Int, []byte) (*big.Int, 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.
+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..8e990f076
--- /dev/null
+++ b/accounts/abi/bind/backends/remote.go
@@ -0,0 +1,216 @@
+// 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"
+)
+
+// 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.
+//
+// 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 (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 {
+		params = []interface{}{}
+	}
+	// Assemble the request object
+	req := &request{
+		JSONRPC: "2.0",
+		ID:      int(atomic.AddUint32(&b.autoid, 1)),
+		Method:  method,
+		Params:  params,
+	}
+	if err := b.client.Send(req); err != nil {
+		return nil, err
+	}
+	res := new(response)
+	if err := b.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
+}
+
+// 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
+	}
+	var hex string
+	if err := json.Unmarshal(res, &hex); err != nil {
+		return 0, err
+	}
+	nonce, ok := new(big.Int).SetString(hex, 0)
+	if !ok {
+		return 0, fmt.Errorf("invalid nonce hex: %s", hex)
+	}
+	return nonce.Uint64(), nil
+}
+
+// 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
+	}
+	var hex string
+	if err := json.Unmarshal(res, &hex); err != nil {
+		return nil, err
+	}
+	price, ok := new(big.Int).SetString(hex, 0)
+	if !ok {
+		return nil, fmt.Errorf("invalid price hex: %s", hex)
+	}
+	return price, nil
+}
+
+// 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"`
+		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
+	}
+	estimate, ok := new(big.Int).SetString(hex, 0)
+	if !ok {
+		return nil, fmt.Errorf("invalid estimate hex: %s", hex)
+	}
+	return estimate, nil
+}
+
+// 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 {
+		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..18e8481c5
--- /dev/null
+++ b/accounts/abi/bind/backends/simulated.go
@@ -0,0 +1,187 @@
+// 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"
+	"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"
+)
+
+// 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 {
+	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.Copy()
+	} else {
+		block = b.blockchain.CurrentBlock()
+		statedb, _ = b.blockchain.State()
+	}
+	// 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(), nil)
+	gaspool := new(core.GasPool).AddGas(common.MaxBig)
+
+	out, _, err := core.ApplyMessage(vmenv, msg, gaspool)
+	return out, err
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+		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(), nil)
+	gaspool := new(core.GasPool).AddGas(common.MaxBig)
+
+	_, gas, err := core.ApplyMessage(vmenv, msg, gaspool)
+	return gas, err
+}
+
+// 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) {
+		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
new file mode 100644
index 000000000..053b4ccc0
--- /dev/null
+++ b/accounts/abi/bind/base.go
@@ -0,0 +1,174 @@
+// 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"
+	"fmt"
+	"math/big"
+
+	"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)
+
+// 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 {
+	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)
+	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,
+	}
+}
+
+// DeployContract deploys a contract onto the Ethereum blockchain and binds the
+// deployment address with a Go wrapper.
+func DeployContract(opts *TransactOpts, abi abi.ABI, bytecode []byte, backend ContractBackend, params ...interface{}) (common.Address, *types.Transaction, *BoundContract, error) {
+	// Otherwise try to deploy the contract
+	c := NewBoundContract(common.Address{}, abi, backend, backend)
+
+	input, err := c.abi.Pack("", params...)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	tx, err := c.transact(opts, nil, append(bytecode, input...))
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	c.address = crypto.CreateAddress(opts.From, tx.Nonce())
+	return c.address, tx, c, nil
+}
+
+// Call invokes the (constant) contract method with params as input values and
+// sets the output to result. The result type might be a single field for simple
+// returns, a slice of interfaces for anonymous returns and a struct for named
+// returns.
+func (c *BoundContract) Call(opts *CallOpts, 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, opts.Pending)
+	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 *TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	// Otherwise pack up the parameters and invoke the contract
+	input, err := c.abi.Pack(method, params...)
+	if err != nil {
+		return nil, err
+	}
+	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 {
+		value = new(big.Int)
+	}
+	nonce := uint64(0)
+	if opts.Nonce == nil {
+		nonce, err = c.transactor.PendingAccountNonce(opts.From)
+		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.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.EstimateGasLimit(opts.From, 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
+	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")
+	}
+	signedTx, err := opts.Signer(opts.From, 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..8b587f1aa
--- /dev/null
+++ b/accounts/abi/bind/bind.go
@@ -0,0 +1,173 @@
+// 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 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"
+	"strings"
+	"text/template"
+	"unicode"
+
+	"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(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
+		}
+		// 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,
+		}
+	}
+	// Generate the contract template data content and render it
+	data := &tmplData{
+		Package:   pkg,
+		Contracts: contracts,
+	}
+	buffer := new(bytes.Buffer)
+
+	funcs := map[string]interface{}{
+		"bindtype": bindType,
+	}
+	tmpl := template.Must(template.New("").Funcs(funcs).Parse(tmplSource))
+	if err := tmpl.Execute(buffer, data); err != nil {
+		return "", err
+	}
+	// 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 string(code), nil
+}
+
+// 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
+	}
+}
+
+// capitalise makes the first character of a string upper case.
+func capitalise(input string) string {
+	return strings.ToUpper(input[:1]) + input[1:]
+}
+
+// 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
+	}
+	for _, out := range method.Outputs {
+		if out.Name == "" {
+			return false
+		}
+	}
+	return true
+}
diff --git a/accounts/abi/bind/bind_test.go b/accounts/abi/bind/bind_test.go
new file mode 100644
index 000000000..c6ed7a630
--- /dev/null
+++ b/accounts/abi/bind/bind_test.go
@@ -0,0 +1,255 @@
+// 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"
+	"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{}, 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
+	{
+		`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{}, 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)
+			}
+		`,
+	},
+	{
+		`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 {
+				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
+// 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(backends.NewNilBackend())\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([]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 {
+			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\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 <http://www.gnu.org/licenses/>.
+
+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}}
+`