refactor: evm signer - tryprocessout

changelog.md

@@ -45,6 +45,7 @@
 * [1766](https://github.com/zeta-chain/node/pull/1766) - Refactors the `PostTxProcessing` EVM hook functionality to deal with invalid withdraw events
 * [1630](https://github.com/zeta-chain/node/pull/1630) - added password prompts for hotkey and tss keyshare in zetaclient
 * [1760](https://github.com/zeta-chain/node/pull/1760) - Make staking keeper private in crosschain module
+* [1809](https://github.com/zeta-chain/node/pull/1809) - Refactored tryprocessout function in evm signer
 
 ### Fixes
 

zetaclient/bitcoin/bitcoin_client_test.go

@@ -19,13 +19,14 @@ import (
 	crosschaintypes "github.com/zeta-chain/zetacore/x/crosschain/types"
 	observertypes "github.com/zeta-chain/zetacore/x/observer/types"
 	"github.com/zeta-chain/zetacore/zetaclient/testutils"
+	"github.com/zeta-chain/zetacore/zetaclient/testutils/stub"
 )
 
 func MockBTCClientMainnet() *BTCChainClient {
 	return &BTCChainClient{
 		chain:      common.BtcMainnetChain(),
-		zetaClient: testutils.MockCoreBridge(),
-		Tss:        testutils.NewMockTSSMainnet(),
+		zetaClient: stub.NewZetaCoreBridge(),
+		Tss:        stub.NewTSSMainnet(),
 	}
 }
 

zetaclient/config/types.go

@@ -82,7 +82,8 @@ type Config struct {
 
 func NewConfig() *Config {
 	return &Config{
-		cfgLock: &sync.RWMutex{},
+		cfgLock:         &sync.RWMutex{},
+		EVMChainConfigs: make(map[int64]*EVMConfig),
 	}
 }
 

zetaclient/evm/base_transaction_data.go

@@ -0,0 +1,179 @@
+package evm
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"math/big"
+
+	ethcommon "github.com/ethereum/go-ethereum/common"
+	"github.com/rs/zerolog"
+	"github.com/zeta-chain/zetacore/common"
+	"github.com/zeta-chain/zetacore/x/crosschain/types"
+	"github.com/zeta-chain/zetacore/zetaclient/interfaces"
+)
+
+const (
+	MinGasLimit = 100_000
+	MaxGasLimit = 1_000_000
+)
+
+// BaseTransactionData is a data structure containing input fields used to construct each type of transaction.
+// This is populated using cctx and other input parameters passed to TryProcessOutTx
+type BaseTransactionData struct {
+	srcChainID *big.Int
+	toChainID  *big.Int
+	sender     ethcommon.Address
+	to         ethcommon.Address
+	asset      ethcommon.Address
+	amount     *big.Int
+	gasPrice   *big.Int
+	gasLimit   uint64
+	message    []byte
+	nonce      uint64
+	height     uint64
+
+	// sendHash field is the inbound message digest that is sent to the destination contract
+	sendHash [32]byte
+
+	// outboundParams field contains data detailing the receiver chain and outbound transaction
+	outboundParams *types.OutboundTxParams
+}
+
+// SetChainAndSender populates the destination address and Chain ID based on the status of the cross chain tx
+// returns true if transaction should be skipped
+// returns false otherwise
+func (txData *BaseTransactionData) SetChainAndSender(cctx *types.CrossChainTx, logger zerolog.Logger) bool {
+	switch cctx.CctxStatus.Status {
+	case types.CctxStatus_PendingRevert:
+		txData.to = ethcommon.HexToAddress(cctx.InboundTxParams.Sender)
+		txData.toChainID = big.NewInt(cctx.InboundTxParams.SenderChainId)
+		logger.Info().Msgf("Abort: reverting inbound")
+	case types.CctxStatus_PendingOutbound:
+		txData.to = ethcommon.HexToAddress(cctx.GetCurrentOutTxParam().Receiver)
+		txData.toChainID = big.NewInt(cctx.GetCurrentOutTxParam().ReceiverChainId)
+	default:
+		logger.Info().Msgf("Transaction doesn't need to be processed status: %d", cctx.CctxStatus.Status)
+		return true
+	}
+	return false
+}
+
+// SetupGas sets the gas limit and price
+func (txData *BaseTransactionData) SetupGas(
+	cctx *types.CrossChainTx,
+	logger zerolog.Logger,
+	client interfaces.EVMRPCClient,
+	chain *common.Chain,
+) error {
+
+	txData.gasLimit = cctx.GetCurrentOutTxParam().OutboundTxGasLimit
+	if txData.gasLimit < MinGasLimit {
+		txData.gasLimit = MinGasLimit
+		logger.Warn().Msgf("gasLimit %d is too low; set to %d", cctx.GetCurrentOutTxParam().OutboundTxGasLimit, txData.gasLimit)
+	}
+	if txData.gasLimit > MaxGasLimit {
+		txData.gasLimit = MaxGasLimit
+		logger.Warn().Msgf("gasLimit %d is too high; set to %d", cctx.GetCurrentOutTxParam().OutboundTxGasLimit, txData.gasLimit)
+	}
+
+	// use dynamic gas price for ethereum chains.
+	// The code below is a fix for https://github.com/zeta-chain/node/issues/1085
+	// doesn't close directly the issue because we should determine if we want to keep using SuggestGasPrice if no OutboundTxGasPrice
+	// we should possibly remove it completely and return an error if no OutboundTxGasPrice is provided because it means no fee is processed on ZetaChain
+	specified, ok := new(big.Int).SetString(cctx.GetCurrentOutTxParam().OutboundTxGasPrice, 10)
+	if !ok {
+		if common.IsEthereumChain(chain.ChainId) {
+			suggested, err := client.SuggestGasPrice(context.Background())
+			if err != nil {
+				return errors.Join(err, fmt.Errorf("cannot get gas price from chain %s ", chain))
+			}
+			txData.gasPrice = roundUpToNearestGwei(suggested)
+		} else {
+			return fmt.Errorf("cannot convert gas price  %s ", cctx.GetCurrentOutTxParam().OutboundTxGasPrice)
+		}
+	} else {
+		txData.gasPrice = specified
+	}
+	return nil
+}
+
+// SetTransactionData populates transaction input fields parsed from the cctx and other parameters
+// returns
+// bool (skipTx) - if the transaction doesn't qualify to be processed the function will return true, meaning that this
+//
+//	cctx will be skipped and false otherwise.
+//
+// error
+func (txData *BaseTransactionData) SetTransactionData(
+	cctx *types.CrossChainTx,
+	evmClient *ChainClient,
+	evmRPC interfaces.EVMRPCClient,
+	logger zerolog.Logger,
+) (bool, error) {
+
+	txData.outboundParams = cctx.GetCurrentOutTxParam()
+	txData.amount = cctx.GetCurrentOutTxParam().Amount.BigInt()
+	txData.nonce = cctx.GetCurrentOutTxParam().OutboundTxTssNonce
+	txData.sender = ethcommon.HexToAddress(cctx.InboundTxParams.Sender)
+	txData.srcChainID = big.NewInt(cctx.InboundTxParams.SenderChainId)
+	txData.asset = ethcommon.HexToAddress(cctx.InboundTxParams.Asset)
+
+	skipTx := txData.SetChainAndSender(cctx, logger)
+	if skipTx {
+		return true, nil
+	}
+
+	toChain := common.GetChainFromChainID(txData.toChainID.Int64())
+	if toChain == nil {
+		return true, fmt.Errorf("unknown chain: %d", txData.toChainID.Int64())
+	}
+
+	// Get nonce, Early return if the cctx is already processed
+	nonce := cctx.GetCurrentOutTxParam().OutboundTxTssNonce
+	included, confirmed, err := evmClient.IsSendOutTxProcessed(cctx, logger)
+	if err != nil {
+		return true, errors.New("IsSendOutTxProcessed failed")
+	}
+	if included || confirmed {
+		logger.Info().Msgf("CCTX already processed; exit signer")
+		return true, nil
+	}
+
+	// Set up gas limit and gas price
+	err = txData.SetupGas(cctx, logger, evmRPC, toChain)
+	if err != nil {
+		return true, err
+	}
+
+	// Get sendHash
+	logger.Info().Msgf("chain %s minting %d to %s, nonce %d, finalized zeta bn %d", toChain, cctx.InboundTxParams.Amount, txData.to.Hex(), nonce, cctx.InboundTxParams.InboundTxFinalizedZetaHeight)
+	sendHash, err := hex.DecodeString(cctx.Index[2:]) // remove the leading 0x
+	if err != nil || len(sendHash) != 32 {
+		return true, fmt.Errorf("decode CCTX %s error", cctx.Index)
+	}
+	copy(txData.sendHash[:32], sendHash[:32])
+
+	// In case there is a pending transaction, make sure this keysign is a transaction replacement
+	pendingTx := evmClient.GetPendingTx(nonce)
+	if pendingTx != nil {
+		if txData.gasPrice.Cmp(pendingTx.GasPrice()) > 0 {
+			logger.Info().Msgf("replace pending outTx %s nonce %d using gas price %d", pendingTx.Hash().Hex(), nonce, txData.gasPrice)
+		} else {
+			logger.Info().Msgf("please wait for pending outTx %s nonce %d to be included", pendingTx.Hash().Hex(), nonce)
+			return true, nil
+		}
+	}
+
+	// Base64 decode message
+	if cctx.GetCurrentOutTxParam().CoinType != common.CoinType_Cmd {
+		txData.message, err = base64.StdEncoding.DecodeString(cctx.RelayedMessage)
+		if err != nil {
+			logger.Err(err).Msgf("decode CCTX.Message %s error", cctx.RelayedMessage)
+		}
+	}
+
+	return false, nil
+}

zetaclient/evm/base_transaction_data_test.go

@@ -0,0 +1,85 @@
+package evm
+
+import (
+	"math/big"
+	"testing"
+
+	ethcommon "github.com/ethereum/go-ethereum/common"
+	"github.com/rs/zerolog"
+	"github.com/stretchr/testify/require"
+	corecommon "github.com/zeta-chain/zetacore/common"
+	"github.com/zeta-chain/zetacore/x/crosschain/types"
+)
+
+func TestSigner_SetChainAndSender(t *testing.T) {
+	// setup inputs
+	cctx, err := getCCTX()
+	require.NoError(t, err)
+
+	txData := &BaseTransactionData{}
+	logger := zerolog.Logger{}
+
+	t.Run("SetChainAndSender PendingRevert", func(t *testing.T) {
+		cctx.CctxStatus.Status = types.CctxStatus_PendingRevert
+		skipTx := txData.SetChainAndSender(cctx, logger)
+
+		require.False(t, skipTx)
+		require.Equal(t, ethcommon.HexToAddress(cctx.InboundTxParams.Sender), txData.to)
+		require.Equal(t, big.NewInt(cctx.InboundTxParams.SenderChainId), txData.toChainID)
+	})
+
+	t.Run("SetChainAndSender PendingOutBound", func(t *testing.T) {
+		cctx.CctxStatus.Status = types.CctxStatus_PendingOutbound
+		skipTx := txData.SetChainAndSender(cctx, logger)
+
+		require.False(t, skipTx)
+		require.Equal(t, ethcommon.HexToAddress(cctx.GetCurrentOutTxParam().Receiver), txData.to)
+		require.Equal(t, big.NewInt(cctx.GetCurrentOutTxParam().ReceiverChainId), txData.toChainID)
+	})
+
+	t.Run("SetChainAndSender Should skip cctx", func(t *testing.T) {
+		cctx.CctxStatus.Status = types.CctxStatus_PendingInbound
+		skipTx := txData.SetChainAndSender(cctx, logger)
+		require.True(t, skipTx)
+	})
+}
+
+func TestSigner_SetupGas(t *testing.T) {
+	cctx, err := getCCTX()
+	require.NoError(t, err)
+
+	evmSigner, err := getNewEvmSigner()
+	require.NoError(t, err)
+
+	txData := &BaseTransactionData{}
+	logger := zerolog.Logger{}
+
+	t.Run("SetupGas_success", func(t *testing.T) {
+		chain := corecommon.BscMainnetChain()
+		err := txData.SetupGas(cctx, logger, evmSigner.EvmClient(), &chain)
+		require.NoError(t, err)
+	})
+
+	t.Run("SetupGas_error", func(t *testing.T) {
+		cctx.GetCurrentOutTxParam().OutboundTxGasPrice = "invalidGasPrice"
+		chain := corecommon.BtcMainnetChain()
+		err := txData.SetupGas(cctx, logger, evmSigner.EvmClient(), &chain)
+		require.Error(t, err)
+	})
+}
+
+func TestSigner_SetTransactionData(t *testing.T) {
+	// Setup evm signer
+	evmSigner, err := getNewEvmSigner()
+	require.NoError(t, err)
+
+	// Setup txData struct
+	txData := BaseTransactionData{}
+	cctx, err := getCCTX()
+	require.NoError(t, err)
+	mockChainClient, err := getNewEvmChainClient()
+	require.NoError(t, err)
+	skip, err := txData.SetTransactionData(cctx, mockChainClient, evmSigner.EvmClient(), zerolog.Logger{})
+	require.False(t, skip)
+	require.NoError(t, err)
+}