Oev 671 txm improvements

pkg/chains/legacyevm/evm_txm.go

@@ -60,6 +60,7 @@ func newEvmTxm(
 				logPoller,
 				opts.KeyStore,
 				estimator,
+				cfg.GasEstimator().LimitTransfer(),
 			)
 			if cfg.Transactions().TransactionManagerV2().DualBroadcast() == nil || !*cfg.Transactions().TransactionManagerV2().DualBroadcast() {
 				return txmv2, err

pkg/txm/attempt_builder.go

@@ -17,20 +17,26 @@ import (
 
 type attemptBuilder struct {
 	gas.EvmFeeEstimator
-	priceMaxKey func(common.Address) *assets.Wei
-	keystore    keys.TxSigner
+	priceMaxKey         func(common.Address) *assets.Wei
+	keystore            keys.TxSigner
+	emptyTxLimitDefault uint64
 }
 
-func NewAttemptBuilder(priceMaxKey func(common.Address) *assets.Wei, estimator gas.EvmFeeEstimator, keystore keys.TxSigner) *attemptBuilder {
+func NewAttemptBuilder(priceMaxKey func(common.Address) *assets.Wei, estimator gas.EvmFeeEstimator, keystore keys.TxSigner, emptyTxLimitDefault uint64) *attemptBuilder {
 	return &attemptBuilder{
-		priceMaxKey:     priceMaxKey,
-		EvmFeeEstimator: estimator,
-		keystore:        keystore,
+		priceMaxKey:         priceMaxKey,
+		EvmFeeEstimator:     estimator,
+		keystore:            keystore,
+		emptyTxLimitDefault: emptyTxLimitDefault,
 	}
 }
 
 func (a *attemptBuilder) NewAttempt(ctx context.Context, lggr logger.Logger, tx *types.Transaction, dynamic bool) (*types.Attempt, error) {
-	fee, estimatedGasLimit, err := a.EvmFeeEstimator.GetFee(ctx, tx.Data, tx.SpecifiedGasLimit, a.priceMaxKey(tx.FromAddress), &tx.FromAddress, &tx.ToAddress)
+	gasLimit := tx.SpecifiedGasLimit
+	if tx.IsPurgeable {
+		gasLimit = a.emptyTxLimitDefault
+	}
+	fee, estimatedGasLimit, err := a.EvmFeeEstimator.GetFee(ctx, tx.Data, gasLimit, a.priceMaxKey(tx.FromAddress), &tx.FromAddress, &tx.ToAddress)
 	if err != nil {
 		return nil, err
 	}
@@ -42,7 +48,11 @@ func (a *attemptBuilder) NewAttempt(ctx context.Context, lggr logger.Logger, tx
 }
 
 func (a *attemptBuilder) NewBumpAttempt(ctx context.Context, lggr logger.Logger, tx *types.Transaction, previousAttempt types.Attempt) (*types.Attempt, error) {
-	bumpedFee, bumpedFeeLimit, err := a.EvmFeeEstimator.BumpFee(ctx, previousAttempt.Fee, tx.SpecifiedGasLimit, a.priceMaxKey(tx.FromAddress), nil)
+	gasLimit := tx.SpecifiedGasLimit
+	if tx.IsPurgeable {
+		gasLimit = a.emptyTxLimitDefault
+	}
+	bumpedFee, bumpedFeeLimit, err := a.EvmFeeEstimator.BumpFee(ctx, previousAttempt.Fee, gasLimit, a.priceMaxKey(tx.FromAddress), nil)
 	if err != nil {
 		return nil, err
 	}

pkg/txm/attempt_builder_test.go

@@ -16,7 +16,7 @@ import (
 )
 
 func TestAttemptBuilder_newLegacyAttempt(t *testing.T) {
-	ab := NewAttemptBuilder(nil, nil, keystest.TxSigner(nil))
+	ab := NewAttemptBuilder(nil, nil, keystest.TxSigner(nil), 100)
 	address := testutils.NewAddress()
 	lggr := logger.Test(t)
 	var gasLimit uint64 = 100
@@ -51,7 +51,7 @@ func TestAttemptBuilder_newLegacyAttempt(t *testing.T) {
 }
 
 func TestAttemptBuilder_newDynamicFeeAttempt(t *testing.T) {
-	ab := NewAttemptBuilder(nil, nil, keystest.TxSigner(nil))
+	ab := NewAttemptBuilder(nil, nil, keystest.TxSigner(nil), 100)
 	address := testutils.NewAddress()
 
 	lggr := logger.Test(t)

pkg/txm/clientwrappers/dualbroadcast/meta_client.go

@@ -27,8 +27,11 @@ import (
 )
 
 const (
-	timeout = time.Second * 5
-	metaABI = `[
+	timeout                    = time.Second * 5
+	NoBidsError                = "no bids"
+	NoSolverOps                = "no solver operations received"
+	NoSolverOpsAfterSimulation = "no valid solver operations after simulation"
+	metaABI                    = `[
   {
     "type": "function",
     "name": "metacall",
@@ -142,7 +145,7 @@ func NewMetaClient(lggr logger.Logger, c MetaClientRPC, ks MetaClientKeystore, c
 	}
 
 	return &MetaClient{
-		lggr:      logger.Sugared(logger.Named(lggr, "Txm.Txm.MetaClient")),
+		lggr:      logger.Sugared(logger.Named(lggr, "Txm.MetaClient")),
 		c:         c,
 		ks:        ks,
 		customURL: customURL,
@@ -179,7 +182,7 @@ func (a *MetaClient) SendTransaction(ctx context.Context, tx *types.Transaction,
 			return nil
 		}
 		a.lggr.Infof("No bids for transactionID(%d): ", tx.ID)
-		return nil
+		return errors.New(NoBidsError)
 	}
 	a.lggr.Infow("Broadcasting attempt to public mempool", "tx", tx)
 	return a.c.SendTransaction(ctx, attempt.SignedTransaction)
@@ -355,7 +358,7 @@ func (a *MetaClient) SendRequest(parentCtx context.Context, tx *types.Transactio
 	}
 
 	if response.Error.ErrorMessage != "" {
-		if strings.Contains(response.Error.ErrorMessage, "no solver operations received") {
+		if strings.Contains(response.Error.ErrorMessage, NoSolverOps) || strings.Contains(response.Error.ErrorMessage, NoSolverOpsAfterSimulation) {
 			a.metrics.RecordBidsReceived(ctx, 0)
 			return nil, nil
 		}
@@ -521,7 +524,7 @@ func (a *MetaClient) SendOperation(ctx context.Context, tx *types.Transaction, a
 	if err != nil {
 		return fmt.Errorf("failed to sign attempt for txID: %v, err: %w", tx.ID, err)
 	}
-	a.lggr.Infow("Intercepted attempt for tx", "txID", tx.ID, "toAddress", meta.ToAddress, "gasLimit", meta.GasLimit,
+	a.lggr.Infow("Intercepted attempt for tx", "txID", tx.ID, "hash", signedTx.Hash(), "toAddress", meta.ToAddress, "gasLimit", meta.GasLimit,
 		"TipCap", tip, "FeeCap", meta.MaxFeePerGas)
 	return a.c.SendTransaction(ctx, signedTx)
 }

pkg/txm/clientwrappers/dualbroadcast/meta_error_handler.go

@@ -0,0 +1,31 @@
+package dualbroadcast
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/common"
+
+	"github.com/smartcontractkit/chainlink-evm/pkg/txm"
+	"github.com/smartcontractkit/chainlink-evm/pkg/txm/types"
+)
+
+type errorHandler struct{}
+
+func NewErrorHandler() *errorHandler {
+	return &errorHandler{}
+}
+
+func (e *errorHandler) HandleError(ctx context.Context, tx *types.Transaction, txErr error, txStore txm.TxStore, setNonce func(common.Address, uint64), isFromBroadcastMethod bool) error {
+	// If this isn't the first broadcast, don't mark the tx as fatal as other txs might be included on-chain.
+	if strings.Contains(txErr.Error(), NoBidsError) && tx.AttemptCount == 1 {
+		if err := txStore.MarkTxFatal(ctx, tx, tx.FromAddress); err != nil {
+			return err
+		}
+		setNonce(tx.FromAddress, *tx.Nonce)
+		return fmt.Errorf("transaction with txID: %d marked as fatal", tx.ID)
+	}
+
+	return txErr
+}

pkg/txm/clientwrappers/dualbroadcast/selector.go

@@ -12,12 +12,16 @@ import (
 	"github.com/smartcontractkit/chainlink-evm/pkg/txm"
 )
 
-func SelectClient(lggr logger.Logger, client client.Client, keyStore keys.ChainStore, url *url.URL, chainID *big.Int) (txm.Client, error) {
+func SelectClient(lggr logger.Logger, client client.Client, keyStore keys.ChainStore, url *url.URL, chainID *big.Int) (txm.Client, txm.ErrorHandler, error) {
 	urlString := url.String()
 	switch {
 	case strings.Contains(urlString, "flashbots"):
-		return NewFlashbotsClient(client, keyStore, url), nil
+		return NewFlashbotsClient(client, keyStore, url), nil, nil
 	default:
-		return NewMetaClient(lggr, client, keyStore, url, chainID)
+		mc, err := NewMetaClient(lggr, client, keyStore, url, chainID)
+		if err != nil {
+			return nil, nil, err
+		}
+		return mc, NewErrorHandler(), nil
 	}
 }

pkg/txm/storage/inmemory_store.go

@@ -1,7 +1,6 @@
 package storage
 
 import (
-	"errors"
 	"fmt"
 	"math/big"
 	"sort"
@@ -122,6 +121,7 @@ func (m *InMemoryStore) CreateEmptyUnconfirmedTransaction(nonce uint64, gasLimit
 		SpecifiedGasLimit: gasLimit,
 		CreatedAt:         time.Now(),
 		State:             txmgr.TxUnconfirmed,
+		IsPurgeable:       true,
 	}
 
 	if _, exists := m.UnconfirmedTransactions[nonce]; exists {
@@ -366,8 +366,15 @@ func (m *InMemoryStore) DeleteAttemptForUnconfirmedTx(transactionNonce uint64, a
 	return fmt.Errorf("attempt with hash: %v for txID: %v was not found", attempt.Hash, attempt.TxID)
 }
 
-func (m *InMemoryStore) MarkTxFatal(*types.Transaction) error {
-	return errors.New("not implemented")
+func (m *InMemoryStore) MarkTxFatal(txToMark *types.Transaction) error {
+	m.Lock()
+	defer m.Unlock()
+
+	// TODO: for now do the simple thing and drop the transaction instead of adding it to the fatal queue.
+	delete(m.UnconfirmedTransactions, *txToMark.Nonce)
+	delete(m.Transactions, txToMark.ID)
+	txToMark.State = txmgr.TxFatalError // update the state in case the caller needs to log
+	return nil
 }
 
 // Orchestrator

pkg/txm/storage/inmemory_store_test.go

@@ -481,6 +481,20 @@ func TestFindTxWithIdempotencyKey(t *testing.T) {
 	assert.Nil(t, itx)
 }
 
+func TestMarkTxFatal(t *testing.T) {
+	t.Parallel()
+	fromAddress := testutils.NewAddress()
+	m := NewInMemoryStore(logger.Test(t), fromAddress, testutils.FixtureChainID)
+
+	var nonce uint64 = 1
+	tx, err := insertUnconfirmedTransaction(m, nonce)
+	require.NoError(t, err)
+	require.NoError(t, m.MarkTxFatal(tx))
+	assert.Equal(t, txmgr.TxFatalError, tx.State)
+	assert.Empty(t, m.UnconfirmedTransactions)
+	assert.Empty(t, m.Transactions)
+}
+
 func TestPruneConfirmedTransactions(t *testing.T) {
 	t.Parallel()
 	fromAddress := testutils.NewAddress()