ABIGEN v2

accounts/abi/bind/base.go

@@ -89,11 +89,13 @@ type WatchOpts struct {
 
 // MetaData collects all metadata for a bound contract.
 type MetaData struct {
-	mu   sync.Mutex
-	Sigs map[string]string
-	Bin  string
-	ABI  string
-	ab   *abi.ABI
+	mu      sync.Mutex
+	Sigs    map[string]string
+	Bin     string
+	ABI     string
+	ab      *abi.ABI
+	Pattern string
+	Deps    []*MetaData
 }
 
 func (m *MetaData) GetAbi() (*abi.ABI, error) {
@@ -151,15 +153,25 @@ func DeployContract(opts *TransactOpts, abi abi.ABI, bytecode []byte, backend Co
 	return c.address, tx, c, nil
 }
 
+// DeployContractRaw deploys a contract onto the Ethereum blockchain and binds the
+// deployment address with a Go wrapper.  It expects its parameters to be abi-encoded
+// bytes.
+func DeployContractRaw(opts *TransactOpts, bytecode []byte, backend ContractBackend, packedParams []byte) (common.Address, *types.Transaction, *BoundContract, error) {
+	c := NewBoundContract(common.Address{}, abi.ABI{}, backend, backend, backend)
+
+	tx, err := c.transact(opts, nil, append(bytecode, packedParams...))
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	c.address = crypto.CreateAddress(opts.From, tx.Nonce())
+	return c.address, tx, c, nil
+}
+
 // Call invokes the (constant) contract method with params as input values and
 // sets the output to result. The result type might be a single field for simple
 // returns, a slice of interfaces for anonymous returns and a struct for named
 // returns.
 func (c *BoundContract) Call(opts *CallOpts, results *[]interface{}, method string, params ...interface{}) error {
-	// Don't crash on a lazy user
-	if opts == nil {
-		opts = new(CallOpts)
-	}
 	if results == nil {
 		results = new([]interface{})
 	}
@@ -168,68 +180,88 @@ func (c *BoundContract) Call(opts *CallOpts, results *[]interface{}, method stri
 	if err != nil {
 		return err
 	}
+
+	output, err := c.call(opts, input)
+	if err != nil {
+		return err
+	}
+
+	if len(*results) == 0 {
+		res, err := c.abi.Unpack(method, output)
+		*results = res
+		return err
+	}
+	res := *results
+	return c.abi.UnpackIntoInterface(res[0], method, output)
+}
+
+// CallRaw executes an eth_call against the contract with the raw calldata as
+// input.  It returns the call's return data or an error.
+func (c *BoundContract) CallRaw(opts *CallOpts, input []byte) ([]byte, error) {
+	return c.call(opts, input)
+}
+
+func (c *BoundContract) call(opts *CallOpts, input []byte) ([]byte, error) {
+	// Don't crash on a lazy user
+	if opts == nil {
+		opts = new(CallOpts)
+	}
 	var (
 		msg    = ethereum.CallMsg{From: opts.From, To: &c.address, Data: input}
 		ctx    = ensureContext(opts.Context)
 		code   []byte
 		output []byte
+		err    error
 	)
 	if opts.Pending {
 		pb, ok := c.caller.(PendingContractCaller)
 		if !ok {
-			return ErrNoPendingState
+			return nil, ErrNoPendingState
 		}
 		output, err = pb.PendingCallContract(ctx, msg)
 		if err != nil {
-			return err
+			return nil, err
 		}
 		if len(output) == 0 {
 			// Make sure we have a contract to operate on, and bail out otherwise.
 			if code, err = pb.PendingCodeAt(ctx, c.address); err != nil {
-				return err
+				return nil, err
 			} else if len(code) == 0 {
-				return ErrNoCode
+				return nil, ErrNoCode
 			}
 		}
 	} else if opts.BlockHash != (common.Hash{}) {
 		bh, ok := c.caller.(BlockHashContractCaller)
 		if !ok {
-			return ErrNoBlockHashState
+			return nil, ErrNoBlockHashState
 		}
 		output, err = bh.CallContractAtHash(ctx, msg, opts.BlockHash)
 		if err != nil {
-			return err
+			return nil, err
 		}
 		if len(output) == 0 {
 			// Make sure we have a contract to operate on, and bail out otherwise.
 			if code, err = bh.CodeAtHash(ctx, c.address, opts.BlockHash); err != nil {
-				return err
+				return nil, err
 			} else if len(code) == 0 {
-				return ErrNoCode
+				return nil, ErrNoCode
 			}
 		}
 	} else {
 		output, err = c.caller.CallContract(ctx, msg, opts.BlockNumber)
 		if err != nil {
-			return err
+			return nil, err
 		}
 		if len(output) == 0 {
 			// Make sure we have a contract to operate on, and bail out otherwise.
 			if code, err = c.caller.CodeAt(ctx, c.address, opts.BlockNumber); err != nil {
-				return err
+				return nil, err
 			} else if len(code) == 0 {
-				return ErrNoCode
+				return nil, ErrNoCode
 			}
 		}
 	}
-
-	if len(*results) == 0 {
-		res, err := c.abi.Unpack(method, output)
-		*results = res
-		return err
-	}
-	res := *results
-	return c.abi.UnpackIntoInterface(res[0], method, output)
+	return output, nil
 }
 
 // Transact invokes the (paid) contract method with params as input values.
@@ -440,7 +472,6 @@ func (c *BoundContract) FilterLogs(opts *FilterOpts, name string, query ...[]int
 	}
 	// Append the event selector to the query parameters and construct the topic set
 	query = append([][]interface{}{{c.abi.Events[name].ID}}, query...)
-
 	topics, err := abi.MakeTopics(query...)
 	if err != nil {
 		return nil, nil, err