Add custom opts in transaction (#195)

* Add custom opts in transaction

* Update changelog

Author: ferranbt

CHANGELOG.md

@@ -1,6 +1,7 @@
 
 # 0.1.2 (Unreleased)
 
+- Add custom `TxnOpts` to send a transaction in `contract` [[GH-195](https://github.com/umbracle/ethgo/issues/195)]
 - Add `ens resolve` command to resolve an ENS name [[GH-196](https://github.com/umbracle/ethgo/issues/196)]
 - Fix signing of typed transactions [[GH-197](https://github.com/umbracle/ethgo/issues/197)]
 - Fix. Use `ethgo.BlockNumber` input to make `Call` in contract [[GH-194](https://github.com/umbracle/ethgo/issues/194)]

Makefile

@@ -3,8 +3,3 @@
 build-artifacts: 
 	@echo "--> Build Artifacts"
 	@sh -c ./scripts/build-artifacts.sh
-
-.PHONY: build-abigen
-build-abigen:
-	@echo "--> Build abigen"
-	@sh -c ./scripts/build-abigen.sh

builtin/ens/ens.go

@@ -14,7 +14,7 @@ import (
 // Provider handles the interactions with the Ethereum 1x node
 type Provider interface {
 	Call(ethgo.Address, []byte, *CallOpts) ([]byte, error)
-	Txn(ethgo.Address, ethgo.Key, []byte, *TxnOpts) (Txn, error)
+	Txn(ethgo.Address, ethgo.Key, []byte) (Txn, error)
 }
 
 type jsonRPCNodeProvider struct {
@@ -40,99 +40,112 @@ func (j *jsonRPCNodeProvider) Call(addr ethgo.Address, input []byte, opts *CallO
 	return raw, nil
 }
 
-func (j *jsonRPCNodeProvider) Txn(addr ethgo.Address, key ethgo.Key, input []byte, opts *TxnOpts) (Txn, error) {
-	var err error
+func (j *jsonRPCNodeProvider) Txn(addr ethgo.Address, key ethgo.Key, input []byte) (Txn, error) {
+	txn := &jsonrpcTransaction{
+		opts:   &TxnOpts{},
+		input:  input,
+		client: j.client,
+		key:    key,
+		to:     addr,
+	}
+	return txn, nil
+}
 
-	from := key.Address()
+type jsonrpcTransaction struct {
+	to     ethgo.Address
+	input  []byte
+	hash   ethgo.Hash
+	opts   *TxnOpts
+	key    ethgo.Key
+	client *jsonrpc.Eth
+	txn    *ethgo.Transaction
+	txnRaw []byte
+}
+
+func (j *jsonrpcTransaction) Hash() ethgo.Hash {
+	return j.hash
+}
+
+func (j *jsonrpcTransaction) WithOpts(opts *TxnOpts) {
+	j.opts = opts
+}
+
+func (j *jsonrpcTransaction) Build() error {
+	var err error
+	from := j.key.Address()
 
 	// estimate gas price
-	if opts.GasPrice == 0 {
-		opts.GasPrice, err = j.client.GasPrice()
+	if j.opts.GasPrice == 0 {
+		j.opts.GasPrice, err = j.client.GasPrice()
 		if err != nil {
-			return nil, err
+			return err
 		}
 	}
 	// estimate gas limit
-	if opts.GasLimit == 0 {
+	if j.opts.GasLimit == 0 {
 		msg := &ethgo.CallMsg{
 			From:     from,
 			To:       nil,
-			Data:     input,
-			Value:    opts.Value,
-			GasPrice: opts.GasPrice,
+			Data:     j.input,
+			Value:    j.opts.Value,
+			GasPrice: j.opts.GasPrice,
 		}
-		if addr != ethgo.ZeroAddress {
-			msg.To = &addr
+		if j.to != ethgo.ZeroAddress {
+			msg.To = &j.to
 		}
-		opts.GasLimit, err = j.client.EstimateGas(msg)
+		j.opts.GasLimit, err = j.client.EstimateGas(msg)
 		if err != nil {
-			return nil, err
+			return err
 		}
 	}
 	// calculate the nonce
-	if opts.Nonce == 0 {
-		opts.Nonce, err = j.client.GetNonce(from, ethgo.Latest)
+	if j.opts.Nonce == 0 {
+		j.opts.Nonce, err = j.client.GetNonce(from, ethgo.Latest)
 		if err != nil {
-			return nil, fmt.Errorf("failed to calculate nonce: %v", err)
+			return fmt.Errorf("failed to calculate nonce: %v", err)
 		}
 	}
 
 	chainID, err := j.client.ChainID()
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	// send transaction
 	rawTxn := &ethgo.Transaction{
 		From:     from,
-		Input:    input,
-		GasPrice: opts.GasPrice,
-		Gas:      opts.GasLimit,
-		Value:    opts.Value,
-		Nonce:    opts.Nonce,
+		Input:    j.input,
+		GasPrice: j.opts.GasPrice,
+		Gas:      j.opts.GasLimit,
+		Value:    j.opts.Value,
+		Nonce:    j.opts.Nonce,
+		ChainID:  chainID,
+	}
+	if j.to != ethgo.ZeroAddress {
+		rawTxn.To = &j.to
 	}
-	if addr != ethgo.ZeroAddress {
-		rawTxn.To = &addr
+	j.txn = rawTxn
+	return nil
+}
+
+func (j *jsonrpcTransaction) Do() error {
+	if j.txn == nil {
+		if err := j.Build(); err != nil {
+			return err
+		}
 	}
 
-	signer := wallet.NewEIP155Signer(chainID.Uint64())
-	signedTxn, err := signer.SignTx(rawTxn, key)
+	signer := wallet.NewEIP155Signer(j.txn.ChainID.Uint64())
+	signedTxn, err := signer.SignTx(j.txn, j.key)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	txnRaw, err := signedTxn.MarshalRLPTo(nil)
 	if err != nil {
-		return nil, err
-	}
-
-	txn := &jsonrpcTransaction{
-		txn:    signedTxn,
-		txnRaw: txnRaw,
-		client: j.client,
+		return err
 	}
-	return txn, nil
-}
 
-type jsonrpcTransaction struct {
-	hash   ethgo.Hash
-	client *jsonrpc.Eth
-	txn    *ethgo.Transaction
-	txnRaw []byte
-}
-
-func (j *jsonrpcTransaction) Hash() ethgo.Hash {
-	return j.hash
-}
-
-func (j *jsonrpcTransaction) EstimatedGas() uint64 {
-	return j.txn.Gas
-}
-
-func (j *jsonrpcTransaction) GasPrice() uint64 {
-	return j.txn.GasPrice
-}
-
-func (j *jsonrpcTransaction) Do() error {
+	j.txnRaw = txnRaw
 	hash, err := j.client.SendRawTransaction(j.txnRaw)
 	if err != nil {
 		return err
@@ -162,8 +175,7 @@ func (j *jsonrpcTransaction) Wait() (*ethgo.Receipt, error) {
 // Txn is the transaction object returned
 type Txn interface {
 	Hash() ethgo.Hash
-	EstimatedGas() uint64
-	GasPrice() uint64
+	WithOpts(opts *TxnOpts)
 	Do() error
 	Wait() (*ethgo.Receipt, error)
 }
@@ -289,7 +301,7 @@ func (a *Contract) Txn(method string, args ...interface{}) (Txn, error) {
 		}
 	}
 
-	txn, err := a.provider.Txn(a.addr, a.key, input, &TxnOpts{})
+	txn, err := a.provider.Txn(a.addr, a.key, input)
 	if err != nil {
 		return nil, err
 	}

builtin/ens/resolver.go

@@ -99,7 +99,7 @@ func TestContract_Deploy(t *testing.T) {
 
 	// create an address and fund it
 	key, _ := wallet.GenerateKey()
-	s.Transfer(key.Address(), big.NewInt(1000000000000000000))
+	s.Fund(key.Address())
 
 	p, _ := jsonrpc.NewClient(s.HTTPAddr())
 
@@ -138,7 +138,7 @@ func TestContract_Transaction(t *testing.T) {
 
 	// create an address and fund it
 	key, _ := wallet.GenerateKey()
-	s.Transfer(key.Address(), big.NewInt(1000000000000000000))
+	s.Fund(key.Address())
 
 	cc := &testutil.Contract{}
 	cc.AddEvent(testutil.NewEvent("A").Add("uint256", true))
@@ -171,7 +171,7 @@ func TestContract_CallAtBlock(t *testing.T) {
 
 	// create an address and fund it
 	key, _ := wallet.GenerateKey()
-	s.Transfer(key.Address(), big.NewInt(1000000000000000000))
+	s.Fund(key.Address())
 
 	cc := &testutil.Contract{}
 	cc.AddCallback(func() string {
@@ -223,3 +223,42 @@ func TestContract_CallAtBlock(t *testing.T) {
 		checkVal(ethgo.BlockNumber(receipt.BlockNumber-1), big.NewInt(1))
 	}
 }
+
+func TestContract_SendValueContractCall(t *testing.T) {
+	s := testutil.NewTestServer(t, nil)
+	defer s.Close()
+
+	key, _ := wallet.GenerateKey()
+	s.Fund(key.Address())
+
+	cc := &testutil.Contract{}
+	cc.AddCallback(func() string {
+		return `
+		function deposit() public payable {
+		}`
+	})
+
+	artifact, addr := s.DeployContract(cc)
+
+	abi, err := abi.NewABI(artifact.Abi)
+	assert.NoError(t, err)
+
+	contract := NewContract(addr, abi, WithJsonRPCEndpoint(s.HTTPAddr()), WithSender(key))
+
+	balance := big.NewInt(1)
+
+	txn, err := contract.Txn("deposit")
+	txn.WithOpts(&TxnOpts{Value: balance})
+	assert.NoError(t, err)
+
+	err = txn.Do()
+	assert.NoError(t, err)
+
+	_, err = txn.Wait()
+	assert.NoError(t, err)
+
+	client, _ := jsonrpc.NewClient(s.HTTPAddr())
+	found, err := client.Eth().GetBalance(addr, ethgo.Latest)
+	assert.NoError(t, err)
+	assert.Equal(t, found, balance)
+}

builtin/erc20/erc20.go

@@ -205,6 +205,10 @@ func (t *TestServer) Call(msg *ethgo.CallMsg) (string, error) {
 	return resp, nil
 }
 
+func (t *TestServer) Fund(address ethgo.Address) *ethgo.Receipt {
+	return t.Transfer(address, big.NewInt(1000000000000000000))
+}
+
 func (t *TestServer) Transfer(address ethgo.Address, value *big.Int) *ethgo.Receipt {
 	receipt, err := t.SendTxn(&ethgo.Transaction{
 		From:  t.accounts[0],