feat: improve ledger testing for solana (#272)

Improves ledger testing by adding calls to SetRoot and including a
solana tx in the proposal. The SetRoot calls ensures that the signature
was accepted by the contract and not only that the signature was
appended to the proposal.

## AI Summary
This pull request includes several changes to the `e2e` and `sdk/solana`
directories, focusing on improving the handling of Solana and EVM chains
in the MCMS (Many Chain Multi-Sig) system. The most important changes
include adding support for Solana transactions in end-to-end tests,
refactoring the initialization of the MCM program, and updating the
executor creation for Solana chains.

### Support for Solana Transactions in E2E Tests:
* Added a new Solana transaction to the `proposal-testing.json` fixture
to support end-to-end tests involving Solana chains.
* Updated the `ledger_test.go` file to include Solana-specific imports
and added a new test suite `ManualLedgerSigningTestSuite` to test manual
ledger signing functionality for both EVM and Solana chains.
[[1]](diffhunk://#diff-046f7b9890699bc5c0782f4c739ef15b5f8be4727b0c2f7cf932fa171d9f514dL1-R158)
[[2]](diffhunk://#diff-046f7b9890699bc5c0782f4c739ef15b5f8be4727b0c2f7cf932fa171d9f514dL67-R237)
[[3]](diffhunk://#diff-046f7b9890699bc5c0782f4c739ef15b5f8be4727b0c2f7cf932fa171d9f514dR263-R266)

### Refactoring Initialization of MCM Program:
* Refactored the `SetupMCM` function to a public helper function
`InitializeMCMProgram` in `common.go` to initialize the MCM program with
the given PDA seed. This change was applied across multiple test files
to standardize the initialization process.
[[1]](diffhunk://#diff-08c1332aeae8454816329010fb4af1c91528b8059a04739329f4cdf8218f06d0L133-R184)
[[2]](diffhunk://#diff-e1fbbd2697b9af2cb0cd1138b6b678e36a35ed1271f94c24fe9489d1ed159cebL32-R32)
[[3]](diffhunk://#diff-d45f8b1fc9ce32967491b3200326fd5fde2a829bc865c8e52cf6a09778fcc5f8L20-R20)
[[4]](diffhunk://#diff-7e3c7e759e7d2c3b7900d53fd6411bbcbcead44a2d1e6ca7b14b85f32574bc64L21-R21)
[[5]](diffhunk://#diff-9b550f2222fbbcfc8af5b5ed60c0b4567f815d9aeb1aecd54ab08b864fd483c0L25-R25)
[[6]](diffhunk://#diff-715e94216372225cfc4c7393c82b553f0b784dcd30d21f067bade69b1ef7c38cL42-R42)

### Updating Executor Creation for Solana Chains:
* Modified the `NewExecutor` function in `executor.go` to change the
order of parameters, placing the encoder parameter first. Corresponding
changes were made in the relevant test files to reflect this update.
[[1]](diffhunk://#diff-2890f328acff17cf8abc91d22a143ac8a1d955b60ec675f6c57770df1d20f860L33-R33)
[[2]](diffhunk://#diff-350968eef1e410e9af2dba47013590938a30c4391bed93d2329c376a33118331L32-R32)
[[3]](diffhunk://#diff-350968eef1e410e9af2dba47013590938a30c4391bed93d2329c376a33118331L173-R173)

These changes enhance the integration and testing capabilities for
Solana chains within the MCMS system, ensuring better support for
multi-chain operations.

Author: ecPablo

e2e/fixtures/proposal-testing.json

@@ -8,21 +8,40 @@
     "3379446385462418246": {
       "startingOpCount": 0,
       "mcmAddress": "0x123"
+    },
+    "16423721717087811551": {
+      "mcmAddress": "6UmMZr5MEqiKWD5jqTJd1WCR5kT8oZuFYBLJFi1o6GQX.mcms-instance-1"
     }
   },
   "description": "proposal for e2e tests",
   "operations": [
     {
       "chainSelector": 3379446385462418246,
       "transaction": {
-        "contractType": "some-contract",
+        "contractType": "some-evm-contract",
         "tags": null,
         "to": "0x1c",
         "data": "MHgw",
         "additionalFields": {
           "value": 100
         }
       }
+    },
+    {
+      "chainSelector": 16423721717087811551,
+      "transaction": {
+        "contractType": "some-solana-program",
+        "tags": null,
+        "to": "4HeqEoSyfYpeC2goFLj9eHgkxV33mR5G7JYAbRsN14uQ",
+        "data": "D2DZq3wEcfN0ZXN0LXRpbWVsb2NrY29udmVydGVyAAAAAAAAAAAAAFF3oPhB0oSxY3h5BmiszWNGktjysKAxcPliXCS0aGa3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB6QyuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAA=",
+        "additionalFields": {
+          "accounts": [
+            {
+              "PublicKey": "4HeqEoSyfYpeC2goFLj9eHgkxV33mR5G7JYAbRsN14uQ"
+            }
+          ]
+        }
+      }
     }
   ]
 }

e2e/ledger/ledger_test.go

@@ -1,45 +1,180 @@
-//go:build ledger && !e2e
-// +build ledger,!e2e
+//go:build e2e
+// +build e2e
 
 package ledger
 
 import (
+	"context"
 	"log"
+	"math/big"
 	"os"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/accounts"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/accounts/usbwallet"
-	"github.com/stretchr/testify/require"
+	"github.com/ethereum/go-ethereum/common"
+	gethTypes "github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/gagliardetto/solana-go"
+	cselectors "github.com/smartcontractkit/chain-selectors"
+	"github.com/stretchr/testify/suite"
 
 	"github.com/smartcontractkit/mcms"
+	e2e "github.com/smartcontractkit/mcms/e2e/tests"
+	solanae2e "github.com/smartcontractkit/mcms/e2e/tests/solana"
 	testutils "github.com/smartcontractkit/mcms/e2e/utils"
 	"github.com/smartcontractkit/mcms/sdk"
+	"github.com/smartcontractkit/mcms/sdk/evm"
+	"github.com/smartcontractkit/mcms/sdk/evm/bindings"
+	solanamcms "github.com/smartcontractkit/mcms/sdk/solana"
 	"github.com/smartcontractkit/mcms/types"
 )
 
+func TestManualLedgerSigningSuite(t *testing.T) {
+	var runLedgerSuite = os.Getenv("RUN_LEDGER_SUITE") == "true"
+	if !runLedgerSuite {
+		t.Skip("Skipping LedgerSuite. Set RUN_LEDGER_SUITE=true to run it.")
+	}
+	suite.Run(t, new(ManualLedgerSigningTestSuite))
+}
+
+// ManualLedgerSigningTestSuite tests the manual ledger signing functionality
+type ManualLedgerSigningTestSuite struct {
+	suite.Suite
+	authEVM             *bind.TransactOpts
+	authSolana          solana.PrivateKey
+	chainSelectorEVM    types.ChainSelector
+	chainSelectorSolana types.ChainSelector
+	e2e.TestSetup
+}
+
+func (s *ManualLedgerSigningTestSuite) deployMCMContractEVM(ctx context.Context) (common.Address, *bindings.ManyChainMultiSig) {
+	// Set auth keys
+	chainID, ok := new(big.Int).SetString(s.BlockchainA.Out.ChainID, 10)
+	privateKeyHex := s.Settings.PrivateKeys[0]
+	privateKey, err := crypto.HexToECDSA(privateKeyHex[2:]) // Strip "0x" prefix
+	s.Require().NoError(err, "Failed to parse private key")
+	auth, err := bind.NewKeyedTransactorWithChainID(privateKey, chainID)
+	s.Require().NoError(err, "Failed to create transactor")
+	s.authEVM = auth
+
+	// Deploy MCMS contract
+	s.Require().True(ok, "Failed to parse chain ID")
+	mcmsAddress, tx, instance, err := bindings.DeployManyChainMultiSig(s.authEVM, s.Client)
+	s.Require().NoError(err, "Failed to deploy contract")
+
+	// Wait for the transaction to be mined
+	receipt, err := bind.WaitMined(ctx, s.Client, tx)
+	s.Require().NoError(err, "Failed to mine deployment transaction")
+	s.Require().Equal(gethTypes.ReceiptStatusSuccessful, receipt.Status)
+
+	return mcmsAddress, instance
+}
+func (s *ManualLedgerSigningTestSuite) initializeMCMSolana(ctx context.Context) (solana.PublicKey, string) {
+	var MCMProgramID = solana.MustPublicKeyFromBase58(s.SolanaChain.SolanaPrograms["mcm"])
+	solanae2e.InitializeMCMProgram(
+		ctx,
+		s.T(),
+		s.SolanaClient,
+		MCMProgramID,
+		mcmInstanceSeed,
+		uint64(s.chainSelectorSolana),
+	)
+
+	programID := solana.MustPublicKeyFromBase58(s.SolanaChain.SolanaPrograms["mcm"])
+	contractAddress := solanamcms.ContractAddress(programID, mcmInstanceSeed)
+
+	return programID, contractAddress
+}
+
+// setRootEVM initializes and MCMS contract and calls set root on it
+func (s *ManualLedgerSigningTestSuite) setRootEVM(
+	ctx context.Context,
+	ledgerAccount common.Address,
+	proposal *mcms.Proposal,
+	instance *bindings.ManyChainMultiSig,
+	executorsMap map[types.ChainSelector]sdk.Executor,
+) {
+	mcmConfig := types.Config{Quorum: 1, Signers: []common.Address{ledgerAccount}}
+
+	// set config
+	configurer := evm.NewConfigurer(s.Client, 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.Client, tx.RawTransaction.(*gethTypes.Transaction))
+	s.Require().NoError(err, "Failed to mine set config transaction")
+
+	// set root
+	executable, err := mcms.NewExecutable(proposal, executorsMap)
+	s.Require().NoError(err)
+	tx, err = executable.SetRoot(ctx, s.chainSelectorEVM)
+	s.Require().NoError(err)
+	s.Require().NotEmpty(tx.Hash)
+}
+
+const privateKeyLedger = "DmPfeHBC8Brf8s5qQXi25bmJ996v6BHRtaLc6AH51yFGSqQpUMy1oHkbbXobPNBdgGH2F29PAmoq9ZZua4K9vCc"
+
+var mcmInstanceSeed = [32]byte{'t', 'e', 's', 't', '-', 's', 'e', 't', 'r', 'o', 'o', 't', 'l', 'e', 'd', 'g', 'e', 'r'}
+
+// setRootSolana initializes and MCMS contract and calls set root on it
+func (s *ManualLedgerSigningTestSuite) setRootSolana(
+	ctx context.Context,
+	mcmProgramID solana.PublicKey,
+	ledgerAccount common.Address,
+	proposal *mcms.Proposal,
+	executorsMap map[types.ChainSelector]sdk.Executor) {
+	// set config
+	mcmAddress := solanamcms.ContractAddress(mcmProgramID, mcmInstanceSeed)
+	mcmConfig := types.Config{Quorum: 1, Signers: []common.Address{ledgerAccount}}
+	configurer := solanamcms.NewConfigurer(s.SolanaClient, s.authSolana, s.chainSelectorSolana)
+	_, err := configurer.SetConfig(ctx, mcmAddress, &mcmConfig, true)
+	s.Require().NoError(err)
+
+	// set root
+	executable, err := mcms.NewExecutable(proposal, executorsMap)
+	s.Require().NoError(err)
+	tx, err := executable.SetRoot(ctx, s.chainSelectorSolana)
+	s.Require().NoError(err)
+
+	// --- assert ---
+	_, err = solana.SignatureFromBase58(tx.Hash)
+	s.Require().NoError(err)
+}
+
 // This test uses real ledger connected device. Remember to connect, unlock it and open ethereum app.
-func TestManualLedgerSigning(t *testing.T) { //nolint:paralleltest
-	t.Log("Starting manual Ledger signing test...")
+func (s *ManualLedgerSigningTestSuite) TestManualLedgerSigning() {
+	s.T().Log("Starting manual Ledger signing test...")
+
+	ctx := context.Background()
+	s.TestSetup = *e2e.InitializeSharedTestSetup(s.T())
+
+	chainDetailsEVM, err := cselectors.GetChainDetailsByChainIDAndFamily(s.BlockchainA.Out.ChainID, s.BlockchainA.Out.Family)
+	s.Require().NoError(err)
+	chainDetailsSolana, err := cselectors.GetChainDetailsByChainIDAndFamily(s.SolanaChain.ChainID, s.SolanaChain.Out.Family)
+	s.Require().NoError(err)
+
+	s.chainSelectorEVM = types.ChainSelector(chainDetailsEVM.ChainSelector)
+	s.chainSelectorSolana = types.ChainSelector(chainDetailsSolana.ChainSelector)
 
 	// Step 1: Detect and connect to the Ledger device
-	t.Log("Checking for connected Ledger devices...")
+	s.T().Log("Checking for connected Ledger devices...")
 	ledgerHub, err := usbwallet.NewLedgerHub()
-	require.NoError(t, err, "Failed to initialize Ledger Hub")
+	s.Require().NoError(err, "Failed to initialize Ledger Hub")
 
 	wallets := ledgerHub.Wallets()
-	require.NotEmpty(t, wallets, "No Ledger devices found. Please connect your Ledger and unlock it.")
+	s.Require().NotEmpty(wallets, "No Ledger devices found. Please connect your Ledger and unlock it.")
 
 	// Use the first available wallet
 	wallet := wallets[0]
-	t.Logf("Found Ledger device: %s\n", wallet.URL().Path)
+	s.T().Logf("Found Ledger device: %s\n", wallet.URL().Path)
 
 	// Open the wallet
-	t.Log("Opening Ledger wallet...")
+	s.T().Log("Opening Ledger wallet...")
 	err = wallet.Open("")
-	require.NoError(t, err, "Failed to open Ledger wallet")
+	s.Require().NoError(err, "Failed to open Ledger wallet")
 
-	t.Log("Ledger wallet opened successfully.")
+	s.T().Log("Ledger wallet opened successfully.")
 
 	// Define the derivation path
 	derivationPath := accounts.DefaultBaseDerivationPath
@@ -49,52 +184,82 @@ func TestManualLedgerSigning(t *testing.T) { //nolint:paralleltest
 	if err != nil {
 		log.Fatalf("Failed to derive account: %v", err)
 	}
-	t.Logf("Derived account: %s\n", account.Address.Hex())
+	s.T().Logf("Derived account: %s\n", account.Address.Hex())
 	accountPublicKey := account.Address.Hex()
 	wallet.Close()
 
-	// Step 2: Load a proposal from a fixture
-	t.Log("Loading proposal from fixture...")
+	// Step 2: Deploy and initialize solana and EVM MCMs
+	mcmsAddressEVM, mcmInstanceEVM := s.deployMCMContractEVM(ctx)
+	mcmProgramID, contractIDSolana := s.initializeMCMSolana(ctx)
+
+	// Step 3: Load a proposal from a fixture
+	s.T().Log("Loading proposal from fixture...")
 	file, err := testutils.ReadFixture("proposal-testing.json")
-	require.NoError(t, err, "Failed to read fixture") // Check immediately after ReadFixture
+	s.Require().NoError(err, "Failed to read fixture") // Check immediately after ReadFixture
 	defer func(file *os.File) {
-		if file != nil {
-			err = file.Close()
-			require.NoError(t, err, "Failed to close file")
-		}
+		s.Require().NotNil(file)
+		err = file.Close()
+		s.Require().NoError(err, "Failed to close file")
 	}(file)
-	require.NoError(t, err)
+	s.Require().NoError(err)
 
 	proposal, err := mcms.NewProposal(file)
-	require.NoError(t, err, "Failed to parse proposal")
-	t.Log("Proposal loaded successfully.")
+	s.Require().NoError(err, "Failed to parse proposal")
+	s.T().Log("Proposal loaded successfully.")
+	proposal.ChainMetadata[s.chainSelectorEVM] = types.ChainMetadata{
+		MCMAddress:      mcmsAddressEVM.String(),
+		StartingOpCount: 0,
+	}
+	proposal.ChainMetadata[s.chainSelectorSolana] = types.ChainMetadata{
+		MCMAddress:      contractIDSolana,
+		StartingOpCount: 0,
+	}
 
-	// Step 3: Create a Signable instance
-	t.Log("Creating Signable instance...")
-	inspectors := map[types.ChainSelector]sdk.Inspector{} // Provide required inspectors
+	// Step 4: Create a Signable instance
+	s.T().Log("Creating Signable instance...")
+	inspectors := map[types.ChainSelector]sdk.Inspector{
+		s.chainSelectorEVM:    evm.NewInspector(s.Client),
+		s.chainSelectorSolana: solanamcms.NewInspector(s.SolanaClient),
+	}
+	encoders, err := proposal.GetEncoders()
+	s.Require().NoError(err)
+	authSolana, err := solana.PrivateKeyFromBase58(privateKeyLedger)
+	s.Require().NoError(err)
+	s.authSolana = authSolana
+	encoderEVM := encoders[s.chainSelectorEVM].(*evm.Encoder)
+	encoderSolana := encoders[s.chainSelectorSolana].(*solanamcms.Encoder)
+	executorEVM := evm.NewExecutor(encoderEVM, s.Client, s.authEVM)
+	executorSolana := solanamcms.NewExecutor(encoderSolana, s.SolanaClient, authSolana)
+	executorsMap := map[types.ChainSelector]sdk.Executor{
+		s.chainSelectorEVM:    executorEVM,
+		s.chainSelectorSolana: executorSolana,
+	}
 	signable, err := mcms.NewSignable(proposal, inspectors)
-	require.NoError(t, err, "Failed to create Signable instance")
-	t.Log("Signable instance created successfully.")
+	s.Require().NoError(err, "Failed to create Signable instance")
+	s.T().Log("Signable instance created successfully.")
 
-	// Step 4: Create a LedgerSigner
-	t.Log("Creating LedgerSigner...")
+	// Step 5: Create a LedgerSigner and sign the proposal
+	s.T().Log("Creating LedgerSigner...")
 	ledgerSigner := mcms.NewLedgerSigner(derivationPath)
 
-	// Step 5: Sign the proposal
-	t.Log("Signing the proposal...")
+	s.T().Log("Signing the proposal...")
 	signature, err := signable.SignAndAppend(ledgerSigner)
-	require.NoError(t, err, "Failed to sign proposal with Ledger")
-	t.Log("Proposal signed successfully.")
-	t.Logf("Signature: R=%s, S=%s, V=%d\n", signature.R.Hex(), signature.S.Hex(), signature.V)
+	s.Require().NoError(err, "Failed to sign proposal with Ledger")
+	s.T().Log("Proposal signed successfully.")
+	s.T().Logf("Signature: R=%s, S=%s, V=%d\n", signature.R.Hex(), signature.S.Hex(), signature.V)
 
 	// Step 6: Validate the signature
-	t.Log("Validating the signature...")
+	s.T().Log("Validating the signature...")
 	hash, err := proposal.SigningHash()
-	require.NoError(t, err, "Failed to compute proposal hash")
+	s.Require().NoError(err, "Failed to compute proposal hash")
 
 	recoveredAddr, err := signature.Recover(hash)
-	require.NoError(t, err, "Failed to recover signer address")
+	s.Require().NoError(err, "Failed to recover signer address")
+
+	s.Require().Equal(accountPublicKey, recoveredAddr.Hex(), "Signature verification failed")
+	s.T().Logf("Signature verified successfully. Signed by: %s\n", recoveredAddr.Hex())
 
-	require.Equal(t, accountPublicKey, recoveredAddr.Hex(), "Signature verification failed")
-	t.Logf("Signature verified successfully. Signed by: %s\n", recoveredAddr.Hex())
+	// Step 7: Call Set Root to verify signature
+	s.setRootEVM(ctx, account.Address, proposal, mcmInstanceEVM, executorsMap)
+	s.setRootSolana(ctx, mcmProgramID, account.Address, proposal, executorsMap)
 }

e2e/tests/evm/signing.go

@@ -62,8 +62,8 @@ func (s *SigningTestSuite) TestReadAndSign() {
 	)
 	s.Require().NoError(err)
 	expected := mcmtypes.Signature{
-		R: common.HexToHash("0x51c12e8721bf27f35a0006b3e3ebd0dac111c4bb62dce7b0bd7a3475b2f708a5"),
-		S: common.HexToHash("0x28f29f2a32f4cd9322883fa252742894cc2796a6fbe9cdabd0c6d996eed452f9"),
+		R: common.HexToHash("0x1ed7807767b09344df63797fa4986ce092730813922ce01563062cf51728ac34"),
+		S: common.HexToHash("0x556721244f77182c1130a5ee8d78ac7067cef52662dbb57b4132c6ec567ecbc8"),
 		V: 0,
 	}
 	s.Require().Equal(expected, signature)