[NONEVM-706][Solana] - Refactor TXM + Rebroadcast Expired Tx functionality

docs/relay/README.md

@@ -43,7 +43,8 @@ chainlink nodes solana create --name=<node-name> --chain-id=<chain-id> --url=<ur
 | `OCR2CacheTTL`        | stale OCR2 cache deadline                                                                                                                                                                                          | 1m          |                                       |
 | `TxTimeout`           | timeout to send tx to rpc endpoint                                                                                                                                                                                 | 1m          |                                       |
 | `TxRetryTimeout`      | duration for tx to be rebroadcast to rpc, txm stops rebroadcast after timeout                                                                                                                                      | 10s          |                                       |
-| `TxConfirmTimeout`    | duration when confirming a tx signature before signature is discarded as unconfirmed                                                                                                                               | 30s         |                                       |
-| `SkipPreflight`       | enable or disable preflight checks when sending tx                                                                                                                                                                 | `true`      | `true`, `false`                       |
+| `TxConfirmTimeout`    | duration when confirming a tx signature before signature is discarded as unconfirmed                                                                                                                               | 30s         |  
+| `TxExpirationRebroadcast`       | enables or disables transaction rebroadcast if expired. Expiration check is performed every `ConfirmPollPeriod`. A transaction is considered expired if the blockhash it was sent with is 150 blocks older than the latest blockhash.                                                                                                                                                                 | `false`      | `true`, `false`                                      |
+| `SkipPreflight`       | enables or disables preflight checks when sending tx                                                                                                                                                                 | `true`      | `true`, `false`                       |
 | `Commitment`          | Confirmation level for solana state and transactions. ([documentation](https://docs.solana.com/developing/clients/jsonrpc-api#configuring-state-commitment))                                                       | `confirmed` | `processed`, `confirmed`, `finalized` |
 | `MaxRetries`          | Parameter when sending transactions, how many times the RPC node will automatically rebroadcast a tx, default = `0` for custom txm rebroadcasting method, set to `-1` to use the RPC node's default retry strategy | `0`         |                                       |

pkg/solana/chain.go

@@ -575,7 +575,7 @@ func (c *chain) sendTx(ctx context.Context, from, to string, amount *big.Int, ba
 	}
 
 	chainTxm := c.TxManager()
-	err = chainTxm.Enqueue(ctx, "", tx, nil,
+	err = chainTxm.Enqueue(ctx, "", tx, nil, blockhash.Value.LastValidBlockHeight,
 		txm.SetComputeUnitLimit(500), // reduce from default 200K limit - should only take 450 compute units
 		// no fee bumping and no additional fee - makes validating balance accurate
 		txm.SetComputeUnitPriceMax(0),

pkg/solana/chain_test.go

@@ -536,7 +536,7 @@ func TestSolanaChain_MultiNode_Txm(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, uint64(0), receiverBal)
 
-	createTx := func(signer solana.PublicKey, sender solana.PublicKey, receiver solana.PublicKey, amt uint64) *solana.Transaction {
+	createTx := func(signer solana.PublicKey, sender solana.PublicKey, receiver solana.PublicKey, amt uint64) (*solana.Transaction, uint64) {
 		selectedClient, err = testChain.getClient()
 		assert.NoError(t, err)
 		hash, hashErr := selectedClient.LatestBlockhash(tests.Context(t))
@@ -553,11 +553,12 @@ func TestSolanaChain_MultiNode_Txm(t *testing.T) {
 			solana.TransactionPayer(signer),
 		)
 		require.NoError(t, txErr)
-		return tx
+		return tx, hash.Value.LastValidBlockHeight
 	}
 
 	// Send funds twice, along with an invalid transaction
-	require.NoError(t, testChain.txm.Enqueue(tests.Context(t), "test_success", createTx(pubKey, pubKey, pubKeyReceiver, solana.LAMPORTS_PER_SOL), nil))
+	tx, lastValidBlockHeight := createTx(pubKey, pubKey, pubKeyReceiver, solana.LAMPORTS_PER_SOL)
+	require.NoError(t, testChain.txm.Enqueue(tests.Context(t), "test_success", tx, nil, lastValidBlockHeight))
 
 	// Wait for new block hash
 	currentBh, err := selectedClient.LatestBlockhash(tests.Context(t))
@@ -578,8 +579,10 @@ NewBlockHash:
 		}
 	}
 
-	require.NoError(t, testChain.txm.Enqueue(tests.Context(t), "test_success_2", createTx(pubKey, pubKey, pubKeyReceiver, solana.LAMPORTS_PER_SOL), nil))
-	require.Error(t, testChain.txm.Enqueue(tests.Context(t), "test_invalidSigner", createTx(pubKeyReceiver, pubKey, pubKeyReceiver, solana.LAMPORTS_PER_SOL), nil)) // cannot sign tx before enqueuing
+	tx2, lastValidBlockHeight2 := createTx(pubKey, pubKey, pubKeyReceiver, solana.LAMPORTS_PER_SOL)
+	require.NoError(t, testChain.txm.Enqueue(tests.Context(t), "test_success_2", tx2, nil, lastValidBlockHeight2))
+	tx3, lastValidBlockHeight3 := createTx(pubKeyReceiver, pubKey, pubKeyReceiver, solana.LAMPORTS_PER_SOL)
+	require.Error(t, testChain.txm.Enqueue(tests.Context(t), "test_invalidSigner", tx3, nil, lastValidBlockHeight3)) // cannot sign tx before enqueuing
 
 	// wait for all txes to finish
 	ctx, cancel := context.WithCancel(tests.Context(t))

pkg/solana/config/config.go

@@ -11,17 +11,18 @@ import (
 
 // Global solana defaults.
 var defaultConfigSet = Chain{
-	BalancePollPeriod:   config.MustNewDuration(5 * time.Second),        // poll period for balance monitoring
-	ConfirmPollPeriod:   config.MustNewDuration(500 * time.Millisecond), // polling for tx confirmation
-	OCR2CachePollPeriod: config.MustNewDuration(time.Second),            // cache polling rate
-	OCR2CacheTTL:        config.MustNewDuration(time.Minute),            // stale cache deadline
-	TxTimeout:           config.MustNewDuration(time.Minute),            // timeout for send tx method in client
-	TxRetryTimeout:      config.MustNewDuration(10 * time.Second),       // duration for tx rebroadcasting to RPC node
-	TxConfirmTimeout:    config.MustNewDuration(30 * time.Second),       // duration before discarding tx as unconfirmed. Set to 0 to disable discarding tx.
-	TxRetentionTimeout:  config.MustNewDuration(0 * time.Second),        // duration to retain transactions after being marked as finalized or errored. Set to 0 to immediately drop transactions.
-	SkipPreflight:       ptr(true),                                      // to enable or disable preflight checks
-	Commitment:          ptr(string(rpc.CommitmentConfirmed)),
-	MaxRetries:          ptr(int64(0)), // max number of retries (default = 0). when config.MaxRetries < 0), interpreted as MaxRetries = nil and rpc node will do a reasonable number of retries
+	BalancePollPeriod:       config.MustNewDuration(5 * time.Second),        // poll period for balance monitoring
+	ConfirmPollPeriod:       config.MustNewDuration(500 * time.Millisecond), // polling for tx confirmation
+	OCR2CachePollPeriod:     config.MustNewDuration(time.Second),            // cache polling rate
+	OCR2CacheTTL:            config.MustNewDuration(time.Minute),            // stale cache deadline
+	TxTimeout:               config.MustNewDuration(time.Minute),            // timeout for send tx method in client
+	TxRetryTimeout:          config.MustNewDuration(10 * time.Second),       // duration for tx rebroadcasting to RPC node
+	TxConfirmTimeout:        config.MustNewDuration(30 * time.Second),       // duration before discarding tx as unconfirmed. Set to 0 to disable discarding tx.
+	TxExpirationRebroadcast: ptr(false),                                     // to enable rebroadcasting of expired transactions
+	TxRetentionTimeout:      config.MustNewDuration(0 * time.Second),        // duration to retain transactions after being marked as finalized or errored. Set to 0 to immediately drop transactions.
+	SkipPreflight:           ptr(true),                                      // to enable or disable preflight checks
+	Commitment:              ptr(string(rpc.CommitmentConfirmed)),
+	MaxRetries:              ptr(int64(0)), // max number of retries (default = 0). when config.MaxRetries < 0), interpreted as MaxRetries = nil and rpc node will do a reasonable number of retries
 
 	// fee estimator
 	FeeEstimatorMode:         ptr("fixed"),
@@ -43,6 +44,7 @@ type Config interface {
 	TxTimeout() time.Duration
 	TxRetryTimeout() time.Duration
 	TxConfirmTimeout() time.Duration
+	TxExpirationRebroadcast() bool
 	TxRetentionTimeout() time.Duration
 	SkipPreflight() bool
 	Commitment() rpc.CommitmentType
@@ -68,6 +70,7 @@ type Chain struct {
 	TxTimeout                *config.Duration
 	TxRetryTimeout           *config.Duration
 	TxConfirmTimeout         *config.Duration
+	TxExpirationRebroadcast  *bool
 	TxRetentionTimeout       *config.Duration
 	SkipPreflight            *bool
 	Commitment               *string
@@ -105,6 +108,9 @@ func (c *Chain) SetDefaults() {
 	if c.TxConfirmTimeout == nil {
 		c.TxConfirmTimeout = defaultConfigSet.TxConfirmTimeout
 	}
+	if c.TxExpirationRebroadcast == nil {
+		c.TxExpirationRebroadcast = defaultConfigSet.TxExpirationRebroadcast
+	}
 	if c.TxRetentionTimeout == nil {
 		c.TxRetentionTimeout = defaultConfigSet.TxRetentionTimeout
 	}

pkg/solana/config/toml.go

@@ -155,6 +155,9 @@ func setFromChain(c, f *Chain) {
 	if f.TxConfirmTimeout != nil {
 		c.TxConfirmTimeout = f.TxConfirmTimeout
 	}
+	if f.TxExpirationRebroadcast != nil {
+		c.TxExpirationRebroadcast = f.TxExpirationRebroadcast
+	}
 	if f.TxRetentionTimeout != nil {
 		c.TxRetentionTimeout = f.TxRetentionTimeout
 	}
@@ -241,6 +244,10 @@ func (c *TOMLConfig) TxConfirmTimeout() time.Duration {
 	return c.Chain.TxConfirmTimeout.Duration()
 }
 
+func (c *TOMLConfig) TxExpirationRebroadcast() bool {
+	return *c.Chain.TxExpirationRebroadcast
+}
+
 func (c *TOMLConfig) TxRetentionTimeout() time.Duration {
 	return c.Chain.TxRetentionTimeout.Duration()
 }

pkg/solana/relay.go

@@ -24,7 +24,7 @@ import (
 var _ TxManager = (*txm.Txm)(nil)
 
 type TxManager interface {
-	Enqueue(ctx context.Context, accountID string, tx *solana.Transaction, txID *string, txCfgs ...txm.SetTxConfig) error
+	Enqueue(ctx context.Context, accountID string, tx *solana.Transaction, txID *string, lastValidBlockHeight uint64, txCfgs ...txm.SetTxConfig) error
 }
 
 var _ relaytypes.Relayer = &Relayer{} //nolint:staticcheck

pkg/solana/transmitter.go

@@ -87,7 +87,7 @@ func (c *Transmitter) Transmit(
 
 	// pass transmit payload to tx manager queue
 	c.lggr.Debugf("Queuing transmit tx: state (%s) + transmissions (%s)", c.stateID.String(), c.transmissionsID.String())
-	if err = c.txManager.Enqueue(ctx, c.stateID.String(), tx, nil); err != nil {
+	if err = c.txManager.Enqueue(ctx, c.stateID.String(), tx, nil, blockhash.Value.LastValidBlockHeight); err != nil {
 		return fmt.Errorf("error on Transmit.txManager.Enqueue: %w", err)
 	}
 	return nil

pkg/solana/transmitter_test.go

@@ -27,7 +27,7 @@ type verifyTxSize struct {
 	s *solana.PrivateKey
 }
 
-func (txm verifyTxSize) Enqueue(_ context.Context, _ string, tx *solana.Transaction, txID *string, _ ...txm.SetTxConfig) error {
+func (txm verifyTxSize) Enqueue(_ context.Context, _ string, tx *solana.Transaction, txID *string, _ uint64, _ ...txm.SetTxConfig) error {
 	// additional components that transaction manager adds to the transaction
 	require.NoError(txm.t, fees.SetComputeUnitPrice(tx, 0))
 	require.NoError(txm.t, fees.SetComputeUnitLimit(tx, 0))