rf: submit trans.

relayer/chains/evm/client.go

@@ -9,7 +9,6 @@ import (
 	ethereum "github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	ethTypes "github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/eth/gasestimator"
 	"github.com/ethereum/go-ethereum/rpc"
 	bridgeContract "github.com/icon-project/centralized-relay/relayer/chains/evm/abi"
 	"github.com/icon-project/centralized-relay/relayer/chains/evm/types"
@@ -89,7 +88,7 @@ type IClient interface {
 	FilterLogs(ctx context.Context, q ethereum.FilterQuery) ([]ethTypes.Log, error)
 	SuggestGasPrice(ctx context.Context) (*big.Int, error)
 	SuggestGasTip(ctx context.Context) (*big.Int, error)
-	NonceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (*big.Int, error)
+	PendingNonceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (*big.Int, error)
 	TransactionByHash(ctx context.Context, blockHash common.Hash) (tx *ethTypes.Transaction, isPending bool, err error)
 	CallContract(ctx context.Context, msg ethereum.CallMsg, blockNumber *big.Int) ([]byte, error)
 	TransactionReceipt(ctx context.Context, txHash common.Hash) (*ethTypes.Receipt, error)
@@ -115,7 +114,7 @@ type IClient interface {
 	ExecuteRollback(opts *bind.TransactOpts, sn *big.Int) (*ethTypes.Transaction, error)
 }
 
-func (c *Client) NonceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (*big.Int, error) {
+func (c *Client) PendingNonceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (*big.Int, error) {
 	nonce, err := c.eth.PendingNonceAt(ctx, account)
 	if err != nil {
 		return nil, err

relayer/chains/evm/provider.go

@@ -162,7 +162,7 @@ func (p *Provider) Wallet() (*keystore.Key, error) {
 		if err := p.RestoreKeystore(ctx); err != nil {
 			return nil, err
 		}
-		nonce, err := p.client.NonceAt(ctx, p.wallet.Address, nil)
+		nonce, err := p.client.PendingNonceAt(ctx, p.wallet.Address, nil)
 		if err != nil {
 			return nil, err
 		}
@@ -208,7 +208,7 @@ func (r *Provider) transferBalance(senderKey, recepientAddress string, amount *b
 
 	fromAddress := crypto.PubkeyToAddress(from.PublicKey)
 
-	nonce, err := r.client.NonceAt(context.TODO(), fromAddress, nil)
+	nonce, err := r.client.PendingNonceAt(context.TODO(), fromAddress, nil)
 	if err != nil {
 		err = errors.Wrap(err, "PendingNonceAt ")
 		return common.Hash{}, err
@@ -252,7 +252,7 @@ func (p *Provider) GetTransationOpts(ctx context.Context) (*bind.TransactOpts, e
 	if err != nil {
 		return nil, err
 	}
-	nonce, err := p.client.NonceAt(ctx, wallet.Address, nil)
+	nonce, err := p.client.PendingNonceAt(ctx, wallet.Address, nil)
 	if err != nil {
 		return nil, err
 	}

relayer/chains/evm/route.go

@@ -38,20 +38,14 @@ func (p *Provider) Route(ctx context.Context, message *providerTypes.Message, ca
 	messageKey := message.MessageKey()
 
 	tx, err := p.SendTransaction(ctx, opts, message, MaxTxFixtures)
+	globalRouteLock.Unlock()
 	if err != nil {
-		globalRouteLock.Unlock()
 		return fmt.Errorf("routing failed: %w", err)
 	}
-	globalRouteLock.Unlock()
 	return p.WaitForTxResult(ctx, tx, messageKey, callback)
 }
 
 func (p *Provider) SendTransaction(ctx context.Context, opts *bind.TransactOpts, message *providerTypes.Message, maxRetry uint8) (*types.Transaction, error) {
-	var (
-		tx  *types.Transaction
-		err error
-	)
-
 	gasLimit, err := p.EstimateGas(ctx, message)
 	if err != nil {
 		return nil, fmt.Errorf("failed to estimate gas: %w", err)
@@ -78,24 +72,23 @@ func (p *Provider) SendTransaction(ctx context.Context, opts *bind.TransactOpts,
 
 	switch message.EventType {
 	case events.EmitMessage:
-		tx, err = p.client.ReceiveMessage(opts, message.Src, new(big.Int).SetUint64(message.Sn), message.Data)
+		return p.client.ReceiveMessage(opts, message.Src, new(big.Int).SetUint64(message.Sn), message.Data)
 	case events.CallMessage:
-		tx, err = p.client.ExecuteCall(opts, new(big.Int).SetUint64(message.ReqID), message.Data)
+		return p.client.ExecuteCall(opts, new(big.Int).SetUint64(message.ReqID), message.Data)
 	case events.SetAdmin:
 		addr := common.HexToAddress(message.Src)
-		tx, err = p.client.SetAdmin(opts, addr)
+		return p.client.SetAdmin(opts, addr)
 	case events.RevertMessage:
-		tx, err = p.client.RevertMessage(opts, new(big.Int).SetUint64(message.Sn))
+		return p.client.RevertMessage(opts, new(big.Int).SetUint64(message.Sn))
 	case events.ClaimFee:
-		tx, err = p.client.ClaimFee(opts)
+		return p.client.ClaimFee(opts)
 	case events.SetFee:
-		tx, err = p.client.SetFee(opts, message.Src, new(big.Int).SetUint64(message.Sn), new(big.Int).SetUint64(message.ReqID))
+		return p.client.SetFee(opts, message.Src, new(big.Int).SetUint64(message.Sn), new(big.Int).SetUint64(message.ReqID))
 	case events.ExecuteRollback:
-		tx, err = p.client.ExecuteRollback(opts, new(big.Int).SetUint64(message.Sn))
+		return p.client.ExecuteRollback(opts, new(big.Int).SetUint64(message.Sn))
 	default:
 		return nil, fmt.Errorf("unknown event type: %s", message.EventType)
 	}
-	return tx, err
 }
 
 func (p *Provider) WaitForTxResult(ctx context.Context, tx *types.Transaction, m *providerTypes.MessageKey, callback providerTypes.TxResponseFunc) error {