Add Transaction Simulation to the TXM

.changeset/hungry-impalas-jog.md

@@ -0,0 +1,5 @@
+---
+"chainlink": minor
+---
+
+Added a tx simulation feature to the chain client to enable testing for zk out-of-counter (OOC) errors

common/client/models.go

@@ -18,6 +18,7 @@ const (
 	InsufficientFunds                        // Tx was rejected due to insufficient funds.
 	ExceedsMaxFee                            // Attempt's fee was higher than the node's limit and got rejected.
 	FeeOutOfValidRange                       // This error is returned when we use a fee price suggested from an RPC, but the network rejects the attempt due to an invalid range(mostly used by L2 chains). Retry by requesting a new suggested fee price.
+	OutOfCounters                            // The error returned when a transaction is too complex to be proven by zk circuits. This error is mainly returned by zk chains.
 	sendTxReturnCodeLen                      // tracks the number of errors. Must always be last
 )
 

common/client/multi_node_test.go

@@ -848,6 +848,14 @@ func TestMultiNode_SendTransaction_aggregateTxResults(t *testing.T) {
 			ExpectedCriticalErr: "expected at least one response on SendTransaction",
 			ResultsByCode:       map[SendTxReturnCode][]error{},
 		},
+		{
+			Name:                "Zk out of counter error",
+			ExpectedTxResult:    "not enough keccak counters to continue the execution",
+			ExpectedCriticalErr: "",
+			ResultsByCode: map[SendTxReturnCode][]error{
+				OutOfCounters: {errors.New("not enough keccak counters to continue the execution")},
+			},
+		},
 	}
 
 	for _, testCase := range testCases {

common/config/chaintype.go

@@ -19,6 +19,7 @@ const (
 	ChainScroll          ChainType = "scroll"
 	ChainWeMix           ChainType = "wemix"
 	ChainXDai            ChainType = "xdai" // Deprecated: use ChainGnosis instead
+	ChainZkEvm           ChainType = "zkevm"
 	ChainZkSync          ChainType = "zksync"
 )
 
@@ -31,13 +32,14 @@ var ErrInvalidChainType = fmt.Errorf("must be one of %s or omitted", strings.Joi
 	string(ChainOptimismBedrock),
 	string(ChainScroll),
 	string(ChainWeMix),
+	string(ChainZkEvm),
 	string(ChainZkSync),
 }, ", "))
 
 // IsValid returns true if the ChainType value is known or empty.
 func (c ChainType) IsValid() bool {
 	switch c {
-	case "", ChainArbitrum, ChainCelo, ChainGnosis, ChainKroma, ChainMetis, ChainOptimismBedrock, ChainScroll, ChainWeMix, ChainXDai, ChainZkSync:
+	case "", ChainArbitrum, ChainCelo, ChainGnosis, ChainKroma, ChainMetis, ChainOptimismBedrock, ChainScroll, ChainWeMix, ChainXDai, ChainZkEvm, ChainZkSync:
 		return true
 	}
 	return false

core/chains/evm/client/chain_client.go

@@ -38,7 +38,8 @@ type chainClient struct {
 		RPCClient,
 		rpc.BatchElem,
 	]
-	logger logger.SugaredLogger
+	logger    logger.SugaredLogger
+	chainType config.ChainType
 }
 
 func NewChainClient(
@@ -269,3 +270,12 @@ func (c *chainClient) TransactionReceipt(ctx context.Context, txHash common.Hash
 func (c *chainClient) LatestFinalizedBlock(ctx context.Context) (*evmtypes.Head, error) {
 	return c.multiNode.LatestFinalizedBlock(ctx)
 }
+
+func (c *chainClient) CheckTxValidity(ctx context.Context, from common.Address, to common.Address, data []byte) error {
+	msg := ethereum.CallMsg{
+		From: from,
+		To:   &to,
+		Data: data,
+	}
+	return SimulateTransaction(ctx, c, c.logger, c.chainType, msg)
+}

core/chains/evm/client/client.go

@@ -95,6 +95,9 @@ type Client interface {
 	PendingCallContract(ctx context.Context, msg ethereum.CallMsg) ([]byte, error)
 
 	IsL2() bool
+
+	// Simulate the transaction prior to sending to catch zk out-of-counters error ahead of time. It will not return an error for non-zk chains.
+	CheckTxValidity(ctx context.Context, from common.Address, to common.Address, data []byte) error
 }
 
 func ContextWithDefaultTimeout() (ctx context.Context, cancel context.CancelFunc) {
@@ -371,3 +374,7 @@ func (client *client) IsL2() bool {
 func (client *client) LatestFinalizedBlock(_ context.Context) (*evmtypes.Head, error) {
 	return nil, pkgerrors.New("not implemented. client was deprecated. New methods are added only to satisfy type constraints while we are migrating to new alternatives")
 }
+
+func (client *client) CheckTxValidity(ctx context.Context, from common.Address, to common.Address, data []byte) error {
+	return pkgerrors.New("not implemented. client was deprecated. New methods are added only to satisfy type constraints while we are migrating to new alternatives")
+}

core/chains/evm/client/errors.go

@@ -63,6 +63,7 @@ const (
 	TransactionAlreadyMined
 	Fatal
 	ServiceUnavailable
+	OutOfCounters
 )
 
 type ClientErrors = map[int]*regexp.Regexp
@@ -227,7 +228,11 @@ var zkSync = ClientErrors{
 	Fatal: regexp.MustCompile(`(?:: |^)(?:exceeds block gas limit|intrinsic gas too low|Not enough gas for transaction validation|Failed to pay the fee to the operator|Error function_selector = 0x, data = 0x|invalid sender. can't start a transaction from a non-account|max(?: priority)? fee per (?:gas|pubdata byte) higher than 2\^64-1|oversized data. max: \d+; actual: \d+)$`),
 }
 
-var clients = []ClientErrors{parity, geth, arbitrum, metis, substrate, avalanche, nethermind, harmony, besu, erigon, klaytn, celo, zkSync}
+var zkEvm = ClientErrors{
+	OutOfCounters: regexp.MustCompile(`(?:: |^)not enough .* counters to continue the execution$`),
+}
+
+var clients = []ClientErrors{parity, geth, arbitrum, metis, substrate, avalanche, nethermind, harmony, besu, erigon, klaytn, celo, zkSync, zkEvm}
 
 func (s *SendError) is(errorType int) bool {
 	if s == nil || s.err == nil {
@@ -309,6 +314,11 @@ func (s *SendError) IsServiceUnavailable() bool {
 	return s.is(ServiceUnavailable)
 }
 
+// IsOutOfCounters is a zk chain specific error returned if the transaction is too complex to prove on zk circuits
+func (s *SendError) IsOutOfCounters() bool {
+	return s.is(OutOfCounters)
+}
+
 // IsTimeout indicates if the error was caused by an exceeded context deadline
 func (s *SendError) IsTimeout() bool {
 	if s == nil {
@@ -511,6 +521,10 @@ func ClassifySendError(err error, lggr logger.SugaredLogger, tx *types.Transacti
 		)
 		return commonclient.ExceedsMaxFee
 	}
+	if sendError.IsOutOfCounters() {
+		lggr.Infow("Transaction encountered zk out-of-counters error", "err", sendError)
+		return commonclient.OutOfCounters
+	}
 	lggr.Criticalw("Unknown error encountered when sending transaction", "err", err, "etx", tx)
 	return commonclient.Unknown
 }

core/chains/evm/client/null_client.go

@@ -231,3 +231,7 @@ func (nc *NullClient) IsL2() bool {
 func (nc *NullClient) LatestFinalizedBlock(_ context.Context) (*evmtypes.Head, error) {
 	return nil, nil
 }
+
+func (nc *NullClient) CheckTxValidity(_ context.Context, _ common.Address, _ common.Address, _ []byte) error {
+	return nil
+}

core/chains/evm/client/simulated_backend_client.go

@@ -774,6 +774,10 @@ func (c *SimulatedBackendClient) ethGetLogs(ctx context.Context, result interfac
 	}
 }
 
+func (c *SimulatedBackendClient) CheckTxValidity(ctx context.Context, from common.Address, to common.Address, data []byte) error {
+	return nil
+}
+
 func toCallMsg(params map[string]interface{}) ethereum.CallMsg {
 	var callMsg ethereum.CallMsg
 	toAddr, err := interfaceToAddress(params["to"])

core/chains/evm/client/tx_simulator.go

@@ -0,0 +1,134 @@
+package client
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/core/types"
+
+	"github.com/smartcontractkit/chainlink-common/pkg/logger"
+	"github.com/smartcontractkit/chainlink/v2/common/config"
+
+	commonclient "github.com/smartcontractkit/chainlink/v2/common/client"
+)
+
+const ErrOutOfCounters = "not enough counters to continue the execution"
+
+type simulatorClient interface {
+	CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error
+}
+
+// ZK chains can return an out-of-counters error
+// This method allows a caller to determine if a tx would fail due to OOC error by simulating the transaction
+// Used as an entry point for custom simulation across different chains
+func SimulateTransaction(ctx context.Context, client simulatorClient, lggr logger.SugaredLogger, chainType config.ChainType, msg ethereum.CallMsg) error {
+	var err error
+	switch chainType {
+	case config.ChainZkEvm:
+		err = simulateTransactionZkEvm(ctx, client, lggr, msg)
+	default:
+		err = simulateTransactionDefault(ctx, client, msg)
+	}
+	// ClassifySendError will not have the proper fields for logging within the method due to the empty Transaction passed
+	code := ClassifySendError(err, lggr, &types.Transaction{}, msg.From, chainType.IsL2())
+	// Only return error if ZK OOC error is identified
+	if code == commonclient.OutOfCounters {
+		return errors.New(ErrOutOfCounters)
+	}
+	return nil
+}
+
+// eth_estimateGas returns out-of-counters (OOC) error if the transaction would result in an overflow
+func simulateTransactionDefault(ctx context.Context, client simulatorClient, msg ethereum.CallMsg) error {
+	var result hexutil.Big
+	errCall := client.CallContext(ctx, &result, "eth_estimateGas", toCallArg(msg), "pending")
+	jsonErr, _ := ExtractRPCError(errCall)
+	if jsonErr != nil && len(jsonErr.Message) > 0 {
+		return errors.New(jsonErr.Message)
+	}
+	return nil
+}
+
+type zkEvmEstimateCountResponse struct {
+	CountersUsed struct {
+		GasUsed              string
+		UsedKeccakHashes     string
+		UsedPoseidonHashes   string
+		UsedPoseidonPaddings string
+		UsedMemAligns        string
+		UsedArithmetics      string
+		UsedBinaries         string
+		UsedSteps            string
+		UsedSHA256Hashes     string
+	}
+	CountersLimit struct {
+		MaxGasUsed          string
+		MaxKeccakHashes     string
+		MaxPoseidonHashes   string
+		MaxPoseidonPaddings string
+		MaxMemAligns        string
+		MaxArithmetics      string
+		MaxBinaries         string
+		MaxSteps            string
+		MaxSHA256Hashes     string
+	}
+	OocError string
+}
+
+// zkEVM implemented a custom zkevm_estimateCounters method to detect if a transaction would result in an out-of-counters (OOC) error
+func simulateTransactionZkEvm(ctx context.Context, client simulatorClient, lggr logger.SugaredLogger, msg ethereum.CallMsg) error {
+	var result zkEvmEstimateCountResponse
+	err := client.CallContext(ctx, &result, "zkevm_estimateCounters", toCallArg(msg), "pending")
+	if err != nil {
+		return fmt.Errorf("failed to simulate tx: %w", err)
+	}
+	if detectZkEvmCounterOverflow(result) && len(result.OocError) > 0 {
+		lggr.Debugw("zkevm_estimateCounters returned", "result", result)
+		return errors.New(result.OocError)
+	}
+	return nil
+}
+
+// Helper method for zkEvm to determine if response indicates an overflow
+func detectZkEvmCounterOverflow(result zkEvmEstimateCountResponse) bool {
+	if result.CountersUsed.UsedKeccakHashes > result.CountersLimit.MaxKeccakHashes ||
+		result.CountersUsed.UsedPoseidonHashes > result.CountersLimit.MaxPoseidonHashes ||
+		result.CountersUsed.UsedPoseidonPaddings > result.CountersLimit.MaxPoseidonPaddings ||
+		result.CountersUsed.UsedMemAligns > result.CountersLimit.MaxMemAligns ||
+		result.CountersUsed.UsedArithmetics > result.CountersLimit.MaxArithmetics ||
+		result.CountersUsed.UsedBinaries > result.CountersLimit.MaxBinaries ||
+		result.CountersUsed.UsedSteps > result.CountersLimit.MaxSteps ||
+		result.CountersUsed.UsedSHA256Hashes > result.CountersLimit.MaxSHA256Hashes {
+		return true
+	}
+	return false
+}
+
+func toCallArg(msg ethereum.CallMsg) interface{} {
+	arg := map[string]interface{}{
+		"from": msg.From,
+		"to":   msg.To,
+	}
+	if len(msg.Data) > 0 {
+		arg["input"] = hexutil.Bytes(msg.Data)
+	}
+	if msg.Value != nil {
+		arg["value"] = (*hexutil.Big)(msg.Value)
+	}
+	if msg.Gas != 0 {
+		arg["gas"] = hexutil.Uint64(msg.Gas)
+	}
+	if msg.GasPrice != nil {
+		arg["gasPrice"] = (*hexutil.Big)(msg.GasPrice)
+	}
+	if msg.GasFeeCap != nil {
+		arg["maxFeePerGas"] = (*hexutil.Big)(msg.GasFeeCap)
+	}
+	if msg.GasTipCap != nil {
+		arg["maxPriorityFeePerGas"] = (*hexutil.Big)(msg.GasTipCap)
+	}
+	return arg
+}