Added ExtraArgs ComputeLimit to CCIP Execute transform func

pkg/solana/chainwriter/chain_writer.go

@@ -20,6 +20,7 @@ import (
 	"github.com/smartcontractkit/chainlink-solana/pkg/solana/codec"
 	"github.com/smartcontractkit/chainlink-solana/pkg/solana/fees"
 	"github.com/smartcontractkit/chainlink-solana/pkg/solana/txm"
+	txmutils "github.com/smartcontractkit/chainlink-solana/pkg/solana/txm/utils"
 	"github.com/smartcontractkit/chainlink-solana/pkg/solana/utils"
 )
 
@@ -309,14 +310,15 @@ func (s *SolanaChainWriterService) SubmitTransaction(ctx context.Context, contra
 	// Filter the lookup table addresses based on which accounts are actually used
 	filteredLookupTableMap := s.FilterLookupTableAddresses(accounts, derivedTableMap, staticTableMap)
 
+	options := []txmutils.SetTxConfig{}
 	// Transform args if necessary
 	if methodConfig.ArgsTransform != "" {
 		transformFunc, tfErr := FindTransform(methodConfig.ArgsTransform)
 		if tfErr != nil {
 			return errorWithDebugID(fmt.Errorf("error finding transform function: %w", tfErr), debugID)
 		}
 		s.lggr.Debugw("Applying args transformation", "contract", contractName, "method", method)
-		args, accounts, err = transformFunc(ctx, args, accounts, derivedTableMap)
+		args, accounts, options, err = transformFunc(ctx, args, accounts, derivedTableMap)
 		if err != nil {
 			return errorWithDebugID(fmt.Errorf("error transforming args: %w", err), debugID)
 		}
@@ -355,8 +357,9 @@ func (s *SolanaChainWriterService) SubmitTransaction(ctx context.Context, contra
 	}
 
 	s.lggr.Debugw("Sending main transaction", "contract", contractName, "method", method)
+
 	// Enqueue transaction
-	if err = s.txm.Enqueue(ctx, methodConfig.FromAddress, tx, &transactionID, blockhash.Value.LastValidBlockHeight); err != nil {
+	if err = s.txm.Enqueue(ctx, methodConfig.FromAddress, tx, &transactionID, blockhash.Value.LastValidBlockHeight, options...); err != nil {
 		return errorWithDebugID(fmt.Errorf("error enqueuing transaction: %w", err), debugID)
 	}
 

pkg/solana/chainwriter/chain_writer_test.go

@@ -33,6 +33,7 @@ import (
 	clientmocks "github.com/smartcontractkit/chainlink-solana/pkg/solana/client/mocks"
 	feemocks "github.com/smartcontractkit/chainlink-solana/pkg/solana/fees/mocks"
 	txmMocks "github.com/smartcontractkit/chainlink-solana/pkg/solana/txm/mocks"
+	txmutils "github.com/smartcontractkit/chainlink-solana/pkg/solana/txm/utils"
 )
 
 type Arguments struct {
@@ -927,7 +928,20 @@ func TestChainWriter_CCIPOfframp(t *testing.T) {
 			require.Len(t, tokenIndexes, 1)
 			require.Equal(t, uint8(3), tokenIndexes[0])
 			return true
-		}), &txID, mock.Anything).Return(nil).Once()
+		}), &txID, mock.Anything, mock.AnythingOfType("utils.SetTxConfig"), mock.AnythingOfType("utils.SetTxConfig")).Return(nil).Run(func(args mock.Arguments) {
+			opt1, ok := args[5].(txmutils.SetTxConfig)
+			require.True(t, ok)
+
+			opt2, ok := args[6].(txmutils.SetTxConfig)
+			require.True(t, ok)
+
+			txConfig := &txmutils.TxConfig{}
+			opt1(txConfig)
+			opt2(txConfig)
+
+			require.Equal(t, false, txConfig.EstimateComputeUnitLimit)
+			require.Equal(t, uint32(1700), txConfig.ComputeUnitLimit)
+		}).Once()
 
 		// stripped back report just for purposes of example
 		abstractReport := ccipocr3.ExecutePluginReportSingleChain{
@@ -936,8 +950,14 @@ func TestChainWriter_CCIPOfframp(t *testing.T) {
 					TokenAmounts: []ccipocr3.RampTokenAmount{
 						{
 							DestTokenAddress: destTokenAddr.Bytes(),
+							DestExecDataDecoded: map[string]any{
+								"destGasAmount": uint32(200),
+							},
 						},
 					},
+					ExtraArgsDecoded: map[string]any{
+						"ComputeUnits": uint32(500),
+					},
 				},
 			},
 		}
@@ -1003,7 +1023,14 @@ func TestChainWriter_CCIPOfframp(t *testing.T) {
 			// The CCIPCommit ArgsTransform should remove the last account since no price updates were provided in the report
 			require.Len(t, tx.Message.Instructions[0].Accounts, 2)
 			return true
-		}), &txID, mock.Anything).Return(nil).Once()
+		}), &txID, mock.Anything, mock.AnythingOfType("utils.SetTxConfig")).Return(nil).Run(func(args mock.Arguments) {
+			opt, ok := args[5].(txmutils.SetTxConfig)
+			require.True(t, ok)
+			txConfig := &txmutils.TxConfig{}
+			opt(txConfig)
+
+			require.Equal(t, true, txConfig.EstimateComputeUnitLimit)
+		}).Once()
 
 		submitErr := cw.SubmitTransaction(ctx, ccipconsts.ContractNameOffRamp, ccipconsts.MethodCommit, args, txID, offrampAddr.String(), nil, nil)
 		require.NoError(t, submitErr)

pkg/solana/chainwriter/transform_registry.go

@@ -7,44 +7,72 @@ import (
 
 	"github.com/gagliardetto/solana-go"
 	"github.com/mitchellh/mapstructure"
-	"github.com/smartcontractkit/chainlink-ccip/chains/solana/gobindings/ccip_offramp"
+
+	txmutils "github.com/smartcontractkit/chainlink-solana/pkg/solana/txm/utils"
+
 	"github.com/smartcontractkit/chainlink-ccip/pkg/types/ccipocr3"
 )
 
 type ReportPostTransform struct {
-	ReportContext  [2][32]byte
-	Report         []byte
-	Info           ccipocr3.ExecuteReportInfo
-	AbstractReport ccip_offramp.ExecutionReportSingleChain
-	TokenIndexes   []byte
+	ReportContext [2][32]byte
+	Report        []byte
+	Info          ccipocr3.ExecuteReportInfo
+	TokenIndexes  []byte
 }
 
-func FindTransform(id string) (func(context.Context, any, solana.AccountMetaSlice, map[string]map[string][]*solana.AccountMeta) (any, solana.AccountMetaSlice, error), error) {
+// TODO: replace with actual value from CCIP on-chain
+const staticCuOverhead = 1000
+
+func FindTransform(id string) (func(context.Context, any, solana.AccountMetaSlice, map[string]map[string][]*solana.AccountMeta) (any, solana.AccountMetaSlice, []txmutils.SetTxConfig, error), error) {
 	switch id {
 	case "CCIPExecute":
-		return CCIPExecuteArgsTransform, nil
+		return CCIPExecuteTransform, nil
 	case "CCIPCommit":
-		return CCIPCommitAccountTransform, nil
+		return CCIPCommitTransform, nil
 	default:
 		return nil, fmt.Errorf("transform not found")
 	}
 }
 
 // This Transform function looks up the token pool addresses in the accounts slice and augments the args
 // with the indexes of the token pool addresses in the accounts slice.
-func CCIPExecuteArgsTransform(ctx context.Context, args any, accounts solana.AccountMetaSlice, tableMap map[string]map[string][]*solana.AccountMeta) (any, solana.AccountMetaSlice, error) {
+func CCIPExecuteTransform(ctx context.Context, args any, accounts solana.AccountMetaSlice, tableMap map[string]map[string][]*solana.AccountMeta) (any, solana.AccountMetaSlice, []txmutils.SetTxConfig, error) {
 	var argsTransformed ReportPostTransform
 	err := mapstructure.Decode(args, &argsTransformed)
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, []txmutils.SetTxConfig{}, err
+	}
+
+	if len(argsTransformed.Info.AbstractReports) != 1 || len(argsTransformed.Info.AbstractReports[0].Messages) != 1 {
+		return nil, nil, []txmutils.SetTxConfig{}, fmt.Errorf("Expected 1 report with 1 message")
+	}
+
+	// Compute Units: static cu overhead + svmExtraArgsV1.computeUnits + sum_per_token(tokenDestGasAmount)
+	cu := argsTransformed.Info.AbstractReports[0].Messages[0].ExtraArgsDecoded["ComputeUnits"]
+	if cu == nil {
+		return nil, nil, []txmutils.SetTxConfig{}, errors.New("missing ComputeUnits in ExtraArgs")
+	}
+	computeUnits := staticCuOverhead + cu.(uint32)
+
+	for _, token := range argsTransformed.Info.AbstractReports[0].Messages[0].TokenAmounts {
+		destGasAmount := token.DestExecDataDecoded["destGasAmount"]
+		if destGasAmount == nil {
+			return nil, nil, []txmutils.SetTxConfig{}, fmt.Errorf("missing destGasAmount in DestExecData")
+		}
+		computeUnits += destGasAmount.(uint32)
+	}
+
+	options := []txmutils.SetTxConfig{
+		txmutils.SetEstimateComputeUnitLimit(false),
+		txmutils.SetComputeUnitLimit(computeUnits),
 	}
 
 	registryTables, exists := tableMap["PoolLookupTable"]
 	// If PoolLookupTable does not exist in the table map, token indexes are not needed
 	// Return with empty TokenIndexes
 	if !exists {
 		argsTransformed.TokenIndexes = []byte{}
-		return argsTransformed, accounts, nil
+		return argsTransformed, accounts, options, nil
 	}
 
 	tokenPoolAddresses := []solana.PublicKey{}
@@ -57,36 +85,36 @@ func CCIPExecuteArgsTransform(ctx context.Context, args any, accounts solana.Acc
 		for _, address := range tokenPoolAddresses {
 			if account.PublicKey == address {
 				if i > 255 {
-					return nil, nil, fmt.Errorf("index %d out of range for uint8", i)
+					return nil, nil, []txmutils.SetTxConfig{}, fmt.Errorf("index %d out of range for uint8", i)
 				}
 				tokenIndexes = append(tokenIndexes, uint8(i)) //nolint:gosec
 			}
 		}
 	}
 
 	if len(tokenIndexes) != len(tokenPoolAddresses) {
-		return nil, nil, fmt.Errorf("missing token pools in accounts")
+		return nil, nil, []txmutils.SetTxConfig{}, fmt.Errorf("missing token pools in accounts")
 	}
 
 	argsTransformed.TokenIndexes = tokenIndexes
-	return argsTransformed, accounts, nil
+	return argsTransformed, accounts, options, nil
 }
 
 // This Transform function trims off the GlobalState account from commit transactions if there are no token or gas price updates
-func CCIPCommitAccountTransform(ctx context.Context, args any, accounts solana.AccountMetaSlice, _ map[string]map[string][]*solana.AccountMeta) (any, solana.AccountMetaSlice, error) {
+func CCIPCommitTransform(ctx context.Context, args any, accounts solana.AccountMetaSlice, _ map[string]map[string][]*solana.AccountMeta) (any, solana.AccountMetaSlice, []txmutils.SetTxConfig, error) {
 	var tokenPriceVals, gasPriceVals [][]byte
 	var err error
 	tokenPriceVals, err = GetValuesAtLocation(args, "Info.TokenPrices.TokenID")
 	if err != nil && !errors.Is(err, errFieldNotFound) {
-		return nil, nil, fmt.Errorf("error getting values at location: %w", err)
+		return nil, nil, []txmutils.SetTxConfig{}, fmt.Errorf("error getting values at location: %w", err)
 	}
 	gasPriceVals, err = GetValuesAtLocation(args, "Info.GasPrices.ChainSel")
 	if err != nil && !errors.Is(err, errFieldNotFound) {
-		return nil, nil, fmt.Errorf("error getting values at location: %w", err)
+		return nil, nil, []txmutils.SetTxConfig{}, fmt.Errorf("error getting values at location: %w", err)
 	}
 	transformedAccounts := accounts
 	if len(tokenPriceVals) == 0 && len(gasPriceVals) == 0 {
 		transformedAccounts = accounts[:len(accounts)-1]
 	}
-	return args, transformedAccounts, nil
+	return args, transformedAccounts, []txmutils.SetTxConfig{txmutils.SetEstimateComputeUnitLimit(true)}, nil
 }