feat(solana)!: enable calling SetConfig without sending the transaction (#310)

This PR enables clients to call SetConfig() without sending the
instructions to the blockchain. Its purpose is to retrieve the
instructions that _would_ be sent -- to, for instance, use this
instructions to build an mcms proposal. The instructions are returned in
the `TransactionResult` object, in the `RawData` attribute (which used
to be called `RawTransaction` and was renamed to reflect the fact it can
hold other arbitrary types).

In order to "activate" this mode, clients must set the optional argument
`SkipTransaction`. For instance:
```go
// standard SetConfig, instructions are sent on-chain
result, err := NewConfigurer(client, auth, chainSelector).SetConfig(...)
assert.True(t, solana.IsSignature(result.Hash))


// SkipTransaction() added to SetConfig() -- instructions are NOT sent on-chain
result, err := NewConfigurer(client, auth, chainSelector, SkipTransaction()).SetConfig(...)
assert.Equal(t, result.Hash, "")
assert.GreaterOrEqual(t, len(result.RawData.([]solana.Instruction)), 4)
```

BREAKING_CHANGE: `RawTransaction` renamed to `RawData`

Author: gustavogama-cll

.changeset/many-paws-type.md

@@ -0,0 +1,5 @@
+---
+"@smartcontractkit/mcms": minor
+---
+
+feat: enable calling SetConfig without sending the transaction

e2e/ledger/ledger_test.go

@@ -102,7 +102,7 @@ func (s *ManualLedgerSigningTestSuite) setRootEVM(
 	configurer := evm.NewConfigurer(s.ClientA, s.authEVM)
 	tx, err := configurer.SetConfig(ctx, instance.Address().Hex(), &mcmConfig, true)
 	s.Require().NoError(err, "Failed to set contract configuration")
-	_, err = bind.WaitMined(ctx, s.ClientA, tx.RawTransaction.(*gethTypes.Transaction))
+	_, err = bind.WaitMined(ctx, s.ClientA, tx.RawData.(*gethTypes.Transaction))
 	s.Require().NoError(err, "Failed to mine set config transaction")
 
 	// set root

e2e/tests/solana/set_config.go

@@ -8,7 +8,10 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/gagliardetto/solana-go"
+
+	"github.com/gagliardetto/solana-go/rpc"
 	"github.com/google/go-cmp/cmp"
+	solanaCommon "github.com/smartcontractkit/chainlink-ccip/chains/solana/utils/common"
 
 	mcmsSolana "github.com/smartcontractkit/mcms/sdk/solana"
 	"github.com/smartcontractkit/mcms/types"
@@ -69,16 +72,51 @@ func (s *SolanaTestSuite) Test_Solana_SetConfig() {
 		},
 	}
 
-	// --- act ---
-	configurer := mcmsSolana.NewConfigurer(s.SolanaClient, auth, s.ChainSelector)
-	signature, err := configurer.SetConfig(ctx, mcmAddress, &config, true)
-	s.Require().NoError(err)
-	_, err = solana.SignatureFromBase58(signature.Hash)
-	s.Require().NoError(err)
+	s.Run("send and confirm instructions to the blockchain", func() {
+		// --- act ---
+		configurer := mcmsSolana.NewConfigurer(s.SolanaClient, auth, s.ChainSelector)
+		result, err := configurer.SetConfig(ctx, mcmAddress, &config, true)
+		s.Require().NoError(err)
+		_, err = solana.SignatureFromBase58(result.Hash)
+		s.Require().NoError(err)
 
-	// --- assert ---
-	gotConfig, err := mcmsSolana.NewInspector(s.SolanaClient).GetConfig(ctx, mcmAddress)
-	s.Require().NoError(err)
-	s.Require().NotNil(gotConfig)
-	s.Require().Empty(cmp.Diff(config, *gotConfig))
+		// --- assert ---
+		gotConfig, err := mcmsSolana.NewInspector(s.SolanaClient).GetConfig(ctx, mcmAddress)
+		s.Require().NoError(err)
+		s.Require().NotNil(gotConfig)
+		s.Require().Empty(cmp.Diff(config, *gotConfig))
+	})
+
+	s.Run("do NOT send transactions to the blockchain", func() {
+		skipTxConfig := types.Config{
+			Quorum: 1,
+			Signers: []common.Address{
+				testEVMAccounts[0].Address,
+			},
+			GroupSigners: []types.Config{},
+		}
+
+		// --- act ---
+		configurer := mcmsSolana.NewConfigurer(s.SolanaClient, auth, s.ChainSelector, mcmsSolana.WithDoNotSendInstructionsOnChain())
+		result, err := configurer.SetConfig(ctx, mcmAddress, &skipTxConfig, true)
+		s.Require().NoError(err)
+
+		// --- assert ---
+		s.Require().Empty(err, result.Hash)
+
+		gotConfig, err := mcmsSolana.NewInspector(s.SolanaClient).GetConfig(ctx, mcmAddress)
+		s.Require().NoError(err)
+		s.Require().NotNil(gotConfig)
+		s.Require().Empty(cmp.Diff(config, *gotConfig)) // previous config should still be valid
+
+		// manually send instructions from the response and confirm that they modified the config
+		instructions := result.RawData.([]solana.Instruction)
+		_, err = solanaCommon.SendAndConfirm(ctx, s.SolanaClient, instructions, auth, rpc.CommitmentConfirmed)
+		s.Require().NoError(err)
+
+		gotConfig, err = mcmsSolana.NewInspector(s.SolanaClient).GetConfig(ctx, mcmAddress)
+		s.Require().NoError(err)
+		s.Require().NotNil(gotConfig)
+		s.Require().Empty(cmp.Diff(skipTxConfig, *gotConfig))
+	})
 }

executable_test.go

@@ -194,7 +194,7 @@ func TestExecutor_ExecuteE2E_SingleChainSingleSignerSingleTX_Success(t *testing.
 	require.NoError(t, err)
 	require.NotNil(t, tx)
 	require.NotEmpty(t, tx.Hash)
-	require.NotNil(t, tx.RawTransaction)
+	require.NotNil(t, tx.RawData)
 	sim.Backend.Commit()
 
 	// Validate Contract State and verify root was set
@@ -208,7 +208,7 @@ func TestExecutor_ExecuteE2E_SingleChainSingleSignerSingleTX_Success(t *testing.
 	require.NoError(t, err)
 	require.NotNil(t, tx)
 	require.NotEmpty(t, tx.Hash)
-	require.NotNil(t, tx.RawTransaction)
+	require.NotNil(t, tx.RawData)
 	sim.Backend.Commit()
 
 	// Check the state of the MCMS contract
@@ -322,7 +322,7 @@ func TestExecutor_ExecuteE2E_SingleChainMultipleSignerSingleTX_Success(t *testin
 	require.NoError(t, err)
 	require.NotNil(t, tx)
 	require.NotEmpty(t, tx.Hash)
-	require.NotNil(t, tx.RawTransaction)
+	require.NotNil(t, tx.RawData)
 	sim.Backend.Commit()
 
 	// Validate Contract State and verify root was set
@@ -335,7 +335,7 @@ func TestExecutor_ExecuteE2E_SingleChainMultipleSignerSingleTX_Success(t *testin
 	tx, err = executable.Execute(ctx, 0)
 	require.NoError(t, err)
 	require.NotNil(t, tx)
-	require.NotNil(t, tx.RawTransaction)
+	require.NotNil(t, tx.RawData)
 	require.NotEqual(t, "", tx.Hash)
 	sim.Backend.Commit()
 
@@ -456,7 +456,7 @@ func TestExecutor_ExecuteE2E_SingleChainSingleSignerMultipleTX_Success(t *testin
 	tx, err := executable.SetRoot(ctx, chaintest.Chain1Selector)
 	require.NoError(t, err)
 	require.NotNil(t, tx)
-	require.NotNil(t, tx.RawTransaction)
+	require.NotNil(t, tx.RawData)
 	require.NotEmpty(t, tx.Hash)
 	sim.Backend.Commit()
 
@@ -472,7 +472,7 @@ func TestExecutor_ExecuteE2E_SingleChainSingleSignerMultipleTX_Success(t *testin
 		tx, err = executable.Execute(ctx, i)
 		require.NoError(t, err)
 		require.NotNil(t, tx)
-		require.NotNil(t, tx.RawTransaction)
+		require.NotNil(t, tx.RawData)
 		require.NotEqual(t, "", tx.Hash)
 
 		sim.Backend.Commit()
@@ -600,7 +600,7 @@ func TestExecutor_ExecuteE2E_SingleChainMultipleSignerMultipleTX_Success(t *test
 	tx, err := executable.SetRoot(ctx, chaintest.Chain1Selector)
 	require.NoError(t, err)
 	require.NotNil(t, tx)
-	require.NotNil(t, tx.RawTransaction)
+	require.NotNil(t, tx.RawData)
 	require.NotEmpty(t, tx.Hash)
 
 	sim.Backend.Commit()
@@ -617,7 +617,7 @@ func TestExecutor_ExecuteE2E_SingleChainMultipleSignerMultipleTX_Success(t *test
 		tx, err = executable.Execute(ctx, i)
 		require.NoError(t, err)
 		require.NotNil(t, tx)
-		require.NotNil(t, tx.RawTransaction)
+		require.NotNil(t, tx.RawData)
 		require.NotEqual(t, "", tx.Hash)
 
 		sim.Backend.Commit()

sdk/evm/configurer.go

@@ -58,8 +58,8 @@ func (c *Configurer) SetConfig(ctx context.Context, mcmAddr string, cfg *types.C
 	}
 
 	return types.TransactionResult{
-		Hash:           tx.Hash().Hex(),
-		ChainFamily:    chain_selectors.FamilyEVM,
-		RawTransaction: tx,
+		Hash:        tx.Hash().Hex(),
+		ChainFamily: chain_selectors.FamilyEVM,
+		RawData:     tx,
 	}, nil
 }

sdk/evm/executor.go

@@ -59,9 +59,9 @@ func (e *Executor) ExecuteOperation(
 	}
 
 	return types.TransactionResult{
-		Hash:           tx.Hash().Hex(),
-		ChainFamily:    chain_selectors.FamilyEVM,
-		RawTransaction: tx,
+		Hash:        tx.Hash().Hex(),
+		ChainFamily: chain_selectors.FamilyEVM,
+		RawData:     tx,
 	}, err
 }
 
@@ -103,8 +103,8 @@ func (e *Executor) SetRoot(
 	}
 
 	return types.TransactionResult{
-		Hash:           tx.Hash().Hex(),
-		ChainFamily:    chain_selectors.FamilyEVM,
-		RawTransaction: tx,
+		Hash:        tx.Hash().Hex(),
+		ChainFamily: chain_selectors.FamilyEVM,
+		RawData:     tx,
 	}, err
 }

sdk/evm/timelock_executor.go

@@ -66,8 +66,8 @@ func (t *TimelockExecutor) Execute(
 	}
 
 	return types.TransactionResult{
-		Hash:           tx.Hash().Hex(),
-		ChainFamily:    chain_selectors.FamilyEVM,
-		RawTransaction: tx,
+		Hash:        tx.Hash().Hex(),
+		ChainFamily: chain_selectors.FamilyEVM,
+		RawData:     tx,
 	}, nil
 }

sdk/solana/common.go

@@ -153,7 +153,18 @@ func sendAndConfirm(
 		return "", nil, fmt.Errorf("unable to validate and build instruction: %w", err)
 	}
 
-	result, err := solanaCommon.SendAndConfirm(ctx, client, []solana.Instruction{instruction}, auth, commitmentType)
+	return sendAndConfirmInstructions(ctx, client, auth, []solana.Instruction{instruction}, commitmentType)
+}
+
+// sendAndConfirm contains the default logic for sending and confirming instructions.
+func sendAndConfirmInstructions(
+	ctx context.Context,
+	client *rpc.Client,
+	auth solana.PrivateKey,
+	instructions []solana.Instruction,
+	commitmentType rpc.CommitmentType,
+) (string, *rpc.GetTransactionResult, error) {
+	result, err := solanaCommon.SendAndConfirm(ctx, client, instructions, auth, commitmentType)
 	if err != nil {
 		return "", nil, fmt.Errorf("unable to send instruction: %w", err)
 	}

sdk/solana/configurer.go

@@ -20,22 +20,53 @@ var _ sdk.Configurer = &Configurer{}
 
 // Configurer configures the MCM contract for Solana chains.
 type Configurer struct {
+	instructionCollection
 	chainSelector types.ChainSelector
 	client        *rpc.Client
 	auth          solana.PrivateKey
+	skipSend      bool
 }
 
 // NewConfigurer creates a new Configurer for Solana chains.
-func NewConfigurer(client *rpc.Client, auth solana.PrivateKey, chainSelector types.ChainSelector) *Configurer {
-	return &Configurer{
+//
+// options:
+//
+//	WithDoNotSendInstructionsOnChain: when selected, the Configurer instance will not
+//		send the Solana instructions to the blockchain.
+func NewConfigurer(
+	client *rpc.Client, auth solana.PrivateKey, chainSelector types.ChainSelector, options ...configurerOption,
+) *Configurer {
+	configurer := &Configurer{
 		client:        client,
 		auth:          auth,
 		chainSelector: chainSelector,
+		skipSend:      false,
+	}
+	for _, opt := range options {
+		opt(configurer)
+	}
+
+	return configurer
+}
+
+type configurerOption func(*Configurer)
+
+func WithDoNotSendInstructionsOnChain() configurerOption {
+	return func(c *Configurer) {
+		c.skipSend = true
 	}
 }
 
 // SetConfig sets the configuration for the MCM contract on the Solana chain.
-func (c *Configurer) SetConfig(ctx context.Context, mcmAddress string, cfg *types.Config, clearRoot bool) (types.TransactionResult, error) {
+//
+// The list of instructions needed to set the configuration is returned in the
+// `RawData` field. And if the instructions were sent on chain (which they are
+// unless the `WithDoNotSendInstructionsOnChain` option was selected in the
+// constructor), the signature of the last instruction is returned in the
+// `Hash` field.
+func (c *Configurer) SetConfig(
+	ctx context.Context, mcmAddress string, cfg *types.Config, clearRoot bool,
+) (types.TransactionResult, error) {
 	programID, pdaSeed, err := ParseContractAddress(mcmAddress)
 	if err != nil {
 		return types.TransactionResult{}, err
@@ -71,12 +102,15 @@ func (c *Configurer) SetConfig(ctx context.Context, mcmAddress string, cfg *type
 		return types.TransactionResult{}, err
 	}
 
-	err = c.preloadSigners(ctx, pdaSeed, solanaSignerAddresses(signerAddresses), configPDA, configSignersPDA)
+	clear(c.instructions)
+	defer clear(c.instructions)
+
+	err = c.preloadSigners(pdaSeed, solanaSignerAddresses(signerAddresses), configPDA, configSignersPDA)
 	if err != nil {
 		return types.TransactionResult{}, fmt.Errorf("unable to preload signatures: %w", err)
 	}
 
-	setConfigInstruction := bindings.NewSetConfigInstruction(
+	err = c.addInstruction("setConfig", bindings.NewSetConfigInstruction(
 		pdaSeed,
 		signerGroups,
 		groupQuorums,
@@ -87,47 +121,50 @@ func (c *Configurer) SetConfig(ctx context.Context, mcmAddress string, cfg *type
 		rootMetadataPDA,
 		expiringRootAndOpCountPDA,
 		c.auth.PublicKey(),
-		solana.SystemProgramID)
-	signature, tx, err := sendAndConfirm(ctx, c.client, c.auth, setConfigInstruction, rpc.CommitmentConfirmed)
+		solana.SystemProgramID))
 	if err != nil {
-		return types.TransactionResult{}, fmt.Errorf("unable to set config: %w", err)
+		return types.TransactionResult{}, err
+	}
+
+	var signature string
+	if !c.skipSend {
+		signature, err = c.sendInstructions(ctx, c.client, c.auth)
+		if err != nil {
+			return types.TransactionResult{}, fmt.Errorf("unable to set config: %w", err)
+		}
 	}
 
 	return types.TransactionResult{
-		Hash:           signature,
-		ChainFamily:    chain_selectors.FamilySolana,
-		RawTransaction: tx,
+		Hash:        signature,
+		ChainFamily: chain_selectors.FamilySolana,
+		RawData:     c.solanaInstructions(),
 	}, nil
 }
 
 func (c *Configurer) preloadSigners(
-	ctx context.Context,
 	mcmName [32]byte,
 	signerAddresses [][20]uint8,
 	configPDA solana.PublicKey,
 	configSignersPDA solana.PublicKey,
 ) error {
-	initSignersInstruction := bindings.NewInitSignersInstruction(mcmName, uint8(len(signerAddresses)), configPDA, //nolint:gosec
-		configSignersPDA, c.auth.PublicKey(), solana.SystemProgramID)
-	_, _, err := sendAndConfirm(ctx, c.client, c.auth, initSignersInstruction, rpc.CommitmentConfirmed)
+	err := c.addInstruction("initSigners", bindings.NewInitSignersInstruction(mcmName, uint8(len(signerAddresses)), //nolint:gosec
+		configPDA, configSignersPDA, c.auth.PublicKey(), solana.SystemProgramID))
 	if err != nil {
-		return fmt.Errorf("unable to initialize signers: %w", err)
+		return err
 	}
 
 	for i, chunkIndex := range chunkIndexes(len(signerAddresses), config.MaxAppendSignerBatchSize) {
-		appendSignersInstructions := bindings.NewAppendSignersInstruction(mcmName,
-			signerAddresses[chunkIndex[0]:chunkIndex[1]], configPDA, configSignersPDA, c.auth.PublicKey())
-		_, _, aerr := sendAndConfirm(ctx, c.client, c.auth, appendSignersInstructions, rpc.CommitmentConfirmed)
-		if aerr != nil {
-			return fmt.Errorf("unable to append signers (%d): %w", i, aerr)
+		err = c.addInstruction(fmt.Sprintf("appendSigners%d", i), bindings.NewAppendSignersInstruction(mcmName,
+			signerAddresses[chunkIndex[0]:chunkIndex[1]], configPDA, configSignersPDA, c.auth.PublicKey()))
+		if err != nil {
+			return err
 		}
 	}
 
-	finalizeSignersInstruction := bindings.NewFinalizeSignersInstruction(mcmName, configPDA, configSignersPDA,
-		c.auth.PublicKey())
-	_, _, err = sendAndConfirm(ctx, c.client, c.auth, finalizeSignersInstruction, rpc.CommitmentConfirmed)
+	err = c.addInstruction("finalizeSigners", bindings.NewFinalizeSignersInstruction(mcmName, configPDA,
+		configSignersPDA, c.auth.PublicKey()))
 	if err != nil {
-		return fmt.Errorf("unable to finalize signers: %w", err)
+		return err
 	}
 
 	return nil
@@ -141,3 +178,54 @@ func solanaSignerAddresses(evmAddresses []evmCommon.Address) [][20]uint8 {
 
 	return solanaAddresses
 }
+
+type labeledInstruction struct {
+	solana.Instruction
+	label string
+}
+
+type instructionCollection struct {
+	instructions []labeledInstruction
+}
+
+func (c *instructionCollection) solanaInstructions() []solana.Instruction {
+	solanaInstructions := make([]solana.Instruction, len(c.instructions))
+	for i, instruction := range c.instructions {
+		solanaInstructions[i] = instruction.Instruction
+	}
+
+	return solanaInstructions
+}
+
+func (c *instructionCollection) addInstruction(label string, instructionBuilder any) error {
+	instruction, err := validateAndBuildSolanaInstruction(instructionBuilder)
+	if err != nil {
+		return fmt.Errorf("unable to validate and build %s instruction: %w", label, err)
+	}
+
+	c.instructions = append(c.instructions, labeledInstruction{instruction, label})
+
+	return nil
+}
+
+func (c *instructionCollection) sendInstructions(
+	ctx context.Context,
+	client *rpc.Client,
+	auth solana.PrivateKey,
+) (string, error) {
+	if len(auth) == 0 {
+		return "", nil
+	}
+
+	var signature string
+	var err error
+	for i, instruction := range c.instructions {
+		signature, _, err = sendAndConfirmInstructions(ctx, client, auth,
+			[]solana.Instruction{instruction}, rpc.CommitmentConfirmed)
+		if err != nil {
+			return "", fmt.Errorf("unable to send instruction %d - %s: %w", i, instruction.label, err)
+		}
+	}
+
+	return signature, nil
+}

sdk/solana/configurer_test.go

@@ -6,10 +6,13 @@ import (
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
+	ag_binary "github.com/gagliardetto/binary"
 	"github.com/gagliardetto/solana-go"
 	"github.com/gagliardetto/solana-go/rpc"
 	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
 	cselectors "github.com/smartcontractkit/chain-selectors"
+	bindings "github.com/smartcontractkit/chainlink-ccip/chains/solana/gobindings/mcm"
 	"github.com/stretchr/testify/require"
 
 	"github.com/smartcontractkit/mcms/sdk/solana/mocks"
@@ -23,9 +26,36 @@ func Test_NewConfigurer(t *testing.T) {
 	auth := solana.MustPrivateKeyFromBase58("DmPfeHBC8Brf8s5qQXi25bmJ996v6BHRtaLc6AH51yFGSqQpUMy1oHkbbXobPNBdgGH2F29PAmoq9ZZua4K9vCc")
 	chainSelector := types.ChainSelector(cselectors.SOLANA_DEVNET.Selector)
 
-	configurer := NewConfigurer(client, auth, chainSelector)
+	tests := []struct {
+		name                string
+		constructorFn       func() *Configurer
+		wantSkipTransaction bool
+	}{
+		{
+			name: "standard args",
+			constructorFn: func() *Configurer {
+				return NewConfigurer(client, auth, chainSelector)
+			},
+			wantSkipTransaction: false,
+		},
+		{
+			name: "skip transaction option",
+			constructorFn: func() *Configurer {
+				return NewConfigurer(client, auth, chainSelector, WithDoNotSendInstructionsOnChain())
+			},
+			wantSkipTransaction: true,
+		},
+	}
 
-	require.NotNil(t, configurer)
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			configurer := tt.constructorFn()
+
+			require.NotNil(t, configurer)
+			require.Equal(t, tt.wantSkipTransaction, configurer.skipSend)
+		})
+	}
 }
 
 func TestConfigurer_SetConfig(t *testing.T) {
@@ -39,14 +69,18 @@ func TestConfigurer_SetConfig(t *testing.T) {
 	clearRoot := false
 
 	tests := []struct {
-		name      string
-		mcmConfig *types.Config
-		setup     func(t *testing.T, configurer *Configurer, mockJSONRPCClient *mocks.JSONRPCClient)
-		want      string
-		wantErr   string
+		name             string
+		auth             solana.PrivateKey
+		options          []configurerOption
+		mcmConfig        *types.Config
+		setup            func(t *testing.T, configurer *Configurer, mockJSONRPCClient *mocks.JSONRPCClient)
+		wantHash         string
+		wantInstructions []solana.Instruction
+		wantErr          string
 	}{
 		{
-			name:      "success",
+			name:      "success - send instructions",
+			auth:      auth,
 			mcmConfig: defaultMcmConfig,
 			setup: func(t *testing.T, configurer *Configurer, mockJSONRPCClient *mocks.JSONRPCClient) {
 				t.Helper()
@@ -62,16 +96,38 @@ func TestConfigurer_SetConfig(t *testing.T) {
 				mockSolanaTransaction(t, mockJSONRPCClient, 13, 23,
 					"52f3VmvW7m9uTQu3PtyibgxnAvEuXDmm9umuHherGjS4pzRR7QXRDKnZhh6b95P7pQxzTgvE1muMNKYEY7YWsS3G", nil, nil)
 			},
-			want: "52f3VmvW7m9uTQu3PtyibgxnAvEuXDmm9umuHherGjS4pzRR7QXRDKnZhh6b95P7pQxzTgvE1muMNKYEY7YWsS3G",
+			wantHash: "52f3VmvW7m9uTQu3PtyibgxnAvEuXDmm9umuHherGjS4pzRR7QXRDKnZhh6b95P7pQxzTgvE1muMNKYEY7YWsS3G",
+			wantInstructions: []solana.Instruction{
+				bindings.NewInitSignersInstructionBuilder().Build(),
+				bindings.NewAppendSignersInstructionBuilder().Build(),
+				bindings.NewFinalizeSignersInstructionBuilder().Build(),
+				bindings.NewSetConfigInstructionBuilder().Build(),
+			},
+		},
+		{
+			name:      "success - do not send instructions",
+			auth:      auth,
+			options:   []configurerOption{WithDoNotSendInstructionsOnChain()},
+			mcmConfig: defaultMcmConfig,
+			setup:     func(t *testing.T, configurer *Configurer, mockJSONRPCClient *mocks.JSONRPCClient) { t.Helper() },
+			wantHash:  "",
+			wantInstructions: []solana.Instruction{
+				bindings.NewInitSignersInstructionBuilder().Build(),
+				bindings.NewAppendSignersInstructionBuilder().Build(),
+				bindings.NewFinalizeSignersInstructionBuilder().Build(),
+				bindings.NewSetConfigInstructionBuilder().Build(),
+			},
 		},
 		{
 			name:      "failure: too many signers",
+			auth:      auth,
 			mcmConfig: &types.Config{Quorum: 1, Signers: generateSigners(t, 181)},
 			setup:     func(t *testing.T, configurer *Configurer, mockJSONRPCClient *mocks.JSONRPCClient) { t.Helper() },
 			wantErr:   "too many signers (max 180)",
 		},
 		{
 			name:      "failure: initialize signers error",
+			auth:      auth,
 			mcmConfig: defaultMcmConfig,
 			setup: func(t *testing.T, configurer *Configurer, mockJSONRPCClient *mocks.JSONRPCClient) {
 				t.Helper()
@@ -80,10 +136,11 @@ func TestConfigurer_SetConfig(t *testing.T) {
 					"4PQcRHQJT4cRQZooAhZMAP9ZXJsAka9DeKvXeYvXAvPpHb4Qkc5rmTSHDA2SZSh9aKPBguBx4kmcyHHbkytoAiRr",
 					nil, fmt.Errorf("initialize signers error"))
 			},
-			wantErr: "unable to initialize signers: unable to send instruction: initialize signers error",
+			wantErr: "unable to set config: unable to send instruction 0 - initSigners: unable to send instruction: initialize signers error",
 		},
 		{
 			name:      "failure: append signers error",
+			auth:      auth,
 			mcmConfig: defaultMcmConfig,
 			setup: func(t *testing.T, configurer *Configurer, mockJSONRPCClient *mocks.JSONRPCClient) {
 				t.Helper()
@@ -97,10 +154,11 @@ func TestConfigurer_SetConfig(t *testing.T) {
 					"7D9XEYRnCn1D5JFrrYMPUaHfog7Vnj5rbPdj7kbULa4hKq7GsnA7Q8KNQfLEgfCawBsW4dcH2MQAp4km1dnjr6V",
 					nil, fmt.Errorf("append signers error"))
 			},
-			wantErr: "unable to append signers (0): unable to send instruction: append signers error",
+			wantErr: "unable to set config: unable to send instruction 1 - appendSigners0: unable to send instruction: append signers error",
 		},
 		{
 			name:      "failure: finalize signers error",
+			auth:      auth,
 			mcmConfig: defaultMcmConfig,
 			setup: func(t *testing.T, configurer *Configurer, mockJSONRPCClient *mocks.JSONRPCClient) {
 				t.Helper()
@@ -116,10 +174,11 @@ func TestConfigurer_SetConfig(t *testing.T) {
 					"2iEeniu3QUgXNsjau8r7fZ7XLb2g1F3q9VJJKvRyyFz4hHgVvhGkLgSUdmRumfXKWv8spJ9ihudGFyPZsPGdp4Ya",
 					nil, fmt.Errorf("finalize signers error"))
 			},
-			wantErr: "unable to finalize signers: unable to send instruction: finalize signers error",
+			wantErr: "unable to set config: unable to send instruction 2 - finalizeSigners: unable to send instruction: finalize signers error",
 		},
 		{
 			name:      "failure: set config error",
+			auth:      auth,
 			mcmConfig: &types.Config{Quorum: 1, Signers: []common.Address{common.HexToAddress("0x1")}},
 			setup: func(t *testing.T, configurer *Configurer, mockJSONRPCClient *mocks.JSONRPCClient) {
 				t.Helper()
@@ -137,21 +196,23 @@ func TestConfigurer_SetConfig(t *testing.T) {
 					"52f3VmvW7m9uTQu3PtyibgxnAvEuXDmm9umuHherGjS4pzRR7QXRDKnZhh6b95P7pQxzTgvE1muMNKYEY7YWsS3G",
 					nil, fmt.Errorf("set config error"))
 			},
-			wantErr: "unable to set config: unable to send instruction: set config error",
+			wantErr: "unable to set config: unable to send instruction 3 - setConfig: unable to send instruction: set config error",
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			configurer, mockJSONRPCClient := newTestConfigurer(t, auth, chainSelector)
+			configurer, mockJSONRPCClient := newTestConfigurer(t, tt.auth, chainSelector, tt.options...)
 			tt.setup(t, configurer, mockJSONRPCClient)
 
 			got, err := configurer.SetConfig(ctx, ContractAddress(testMCMProgramID, testPDASeed), tt.mcmConfig, clearRoot)
 
 			if tt.wantErr == "" {
 				require.NoError(t, err)
-				require.Empty(t, cmp.Diff(tt.want, got.Hash))
+				require.Empty(t, cmp.Diff(tt.wantHash, got.Hash))
+				require.Empty(t, cmp.Diff(tt.wantInstructions, got.RawData.([]solana.Instruction),
+					cmpopts.IgnoreFields(ag_binary.BaseVariant{}, "Impl")))
 			} else {
 				require.ErrorContains(t, err, tt.wantErr)
 			}
@@ -161,11 +222,13 @@ func TestConfigurer_SetConfig(t *testing.T) {
 
 // ----- helpers -----
 
-func newTestConfigurer(t *testing.T, auth solana.PrivateKey, chainSelector types.ChainSelector) (*Configurer, *mocks.JSONRPCClient) {
+func newTestConfigurer(
+	t *testing.T, auth solana.PrivateKey, chainSelector types.ChainSelector, options ...configurerOption,
+) (*Configurer, *mocks.JSONRPCClient) {
 	t.Helper()
 
 	mockJSONRPCClient := mocks.NewJSONRPCClient(t)
 	client := rpc.NewWithCustomRPCClient(mockJSONRPCClient)
 
-	return NewConfigurer(client, auth, chainSelector), mockJSONRPCClient
+	return NewConfigurer(client, auth, chainSelector, options...), mockJSONRPCClient
 }

sdk/solana/executor.go

@@ -113,9 +113,9 @@ func (e *Executor) ExecuteOperation(
 	}
 
 	return types.TransactionResult{
-		Hash:           signature,
-		ChainFamily:    chain_selectors.FamilySolana,
-		RawTransaction: tx,
+		Hash:        signature,
+		ChainFamily: chain_selectors.FamilySolana,
+		RawData:     tx,
 	}, nil
 }
 
@@ -186,9 +186,9 @@ func (e *Executor) SetRoot(
 	}
 
 	return types.TransactionResult{
-		Hash:           signature,
-		ChainFamily:    chain_selectors.FamilySolana,
-		RawTransaction: tx,
+		Hash:        signature,
+		ChainFamily: chain_selectors.FamilySolana,
+		RawData:     tx,
 	}, nil
 }
 

sdk/solana/executor_test.go

@@ -180,7 +180,7 @@ func TestExecutor_ExecuteOperation(t *testing.T) {
 			} else {
 				require.NoError(t, err)
 				require.NotNil(t, got)
-				require.NotNil(t, got.RawTransaction)
+				require.NotNil(t, got.RawData)
 				require.Equalf(t, tt.want, got.Hash, "%q. Executor.ExecuteOperation()", tt.name)
 			}
 		})
@@ -357,7 +357,7 @@ func TestExecutor_SetRoot(t *testing.T) {
 			if tt.wantErr == "" {
 				require.NoError(t, err)
 				require.NotNil(t, got)
-				require.NotNil(t, got.RawTransaction)
+				require.NotNil(t, got.RawData)
 				require.Empty(t, cmp.Diff(tt.want, got.Hash))
 			} else {
 				require.ErrorContains(t, err, tt.wantErr)

sdk/solana/timelock_executor.go

@@ -95,8 +95,8 @@ func (e *TimelockExecutor) Execute(
 	}
 
 	return types.TransactionResult{
-		Hash:           signature,
-		ChainFamily:    chain_selectors.FamilySolana,
-		RawTransaction: tx,
+		Hash:        signature,
+		ChainFamily: chain_selectors.FamilySolana,
+		RawData:     tx,
 	}, nil
 }

types/transaction.go

@@ -4,15 +4,15 @@ package types
 // It contains the hash of the transaction and the transaction itself.
 // Users of this struct should cast the transaction to the appropriate type.
 type TransactionResult struct {
-	Hash           string `json:"hash"`
-	ChainFamily    string `json:"chainFamily"`
-	RawTransaction any    `json:"tx"`
+	Hash        string `json:"hash"`
+	ChainFamily string `json:"chainFamily"`
+	RawData     any    `json:"rawData"`
 }
 
-func NewTransactionResult(hash string, tx any, cf string) TransactionResult {
+func NewTransactionResult(hash string, rawData any, cf string) TransactionResult {
 	return TransactionResult{
-		Hash:           hash,
-		ChainFamily:    cf,
-		RawTransaction: tx,
+		Hash:        hash,
+		ChainFamily: cf,
+		RawData:     rawData,
 	}
 }