Updated simulation to set max CU limit and enabled sig verification

pkg/solana/txm/txm.go

@@ -28,9 +28,10 @@ import (
 
 const (
 	MaxQueueLen                    = 1000
-	MaxRetryTimeMs                 = 250 // max tx retry time (exponential retry will taper to retry every 0.25s)
-	MaxSigsToConfirm               = 256 // max number of signatures in GetSignatureStatus call
-	EstimateComputeUnitLimitBuffer = 10  // percent buffer added on top of estimated compute unit limits to account for any variance
+	MaxRetryTimeMs                 = 250       // max tx retry time (exponential retry will taper to retry every 0.25s)
+	MaxSigsToConfirm               = 256       // max number of signatures in GetSignatureStatus call
+	EstimateComputeUnitLimitBuffer = 10        // percent buffer added on top of estimated compute unit limits to account for any variance
+	MaxComputeUnitLimit            = 1_400_000 // max compute unit limit a transaction can have
 )
 
 var _ services.Service = (*Txm)(nil)
@@ -613,7 +614,18 @@ func (txm *Txm) simulateTx(ctx context.Context, tx *solanaGo.Transaction) (res *
 		return
 	}
 
-	res, err = client.SimulateTx(ctx, tx, nil) // use default options (does not verify signatures)
+	// Copy tx to avoid changing the original tx
+	txCopy := *tx
+
+	// Set max compute unit limit when simulating a transaction to avoid getting an error for exceeding the default 200k compute unit limit
+	if computeUnitLimitErr := fees.SetComputeUnitLimit(&txCopy, fees.ComputeUnitLimit(MaxComputeUnitLimit)); computeUnitLimitErr != nil {
+		// This error can occur if endpoint goes down or if invalid signature
+		txm.lggr.Errorw("failed to set compute unit limit when simulating tx", "error", computeUnitLimitErr)
+		return nil, computeUnitLimitErr
+	}
+
+	// Simulate with signature verification since it can have a significant impact on compute units
+	res, err = client.SimulateTx(ctx, &txCopy, &rpc.SimulateTransactionOpts{SigVerify: true})
 	if err != nil {
 		// This error can occur if endpoint goes down or if invalid signature
 		txm.lggr.Errorw("failed to simulate tx", "error", err)

pkg/solana/txm/txm_unit_test.go

@@ -14,6 +14,7 @@ import (
 	solanaClient "github.com/smartcontractkit/chainlink-solana/pkg/solana/client"
 	clientmocks "github.com/smartcontractkit/chainlink-solana/pkg/solana/client/mocks"
 	"github.com/smartcontractkit/chainlink-solana/pkg/solana/config"
+	"github.com/smartcontractkit/chainlink-solana/pkg/solana/fees"
 	solanatxm "github.com/smartcontractkit/chainlink-solana/pkg/solana/txm"
 	keyMocks "github.com/smartcontractkit/chainlink-solana/pkg/solana/txm/mocks"
 
@@ -25,7 +26,6 @@ import (
 
 func TestTxm_EstimateComputeUnitLimit(t *testing.T) {
 	t.Parallel()
-
 	ctx := tests.Context(t)
 
 	// setup mock keystore
@@ -57,7 +57,17 @@ func TestTxm_EstimateComputeUnitLimit(t *testing.T) {
 				Blockhash:            solana.Hash{},
 			},
 		}, nil).Once()
-		client.On("SimulateTx", mock.Anything, mock.Anything, mock.Anything).Return(&rpc.SimulateTransactionResult{
+		client.On("SimulateTx", mock.Anything, mock.IsType(&solana.Transaction{}), mock.IsType(&rpc.SimulateTransactionOpts{})).Run(func(args mock.Arguments) {
+			// Validate max compute unit limit is set in transaction
+			tx := args.Get(1).(*solana.Transaction)
+			limit, err := fees.ParseComputeUnitLimit(tx.Message.Instructions[1].Data)
+			require.NoError(t, err)
+			require.Equal(t, fees.ComputeUnitLimit(solanatxm.MaxComputeUnitLimit), limit)
+
+			// Validate signature verification is enabled
+			opts := args.Get(2).(*rpc.SimulateTransactionOpts)
+			require.True(t, opts.SigVerify)
+		}).Return(&rpc.SimulateTransactionResult{
 			Err:           nil,
 			UnitsConsumed: &usedCompute,
 		}, nil).Once()