wip: better integration tests with rmnremote program

Author: gustavogama-cll

pkg/timelock/operations_solana.go

@@ -4,9 +4,11 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"strings"
 
 	"github.com/gagliardetto/solana-go"
 	"github.com/gagliardetto/solana-go/rpc"
+	"github.com/samber/lo"
 	mcmssolanasdk "github.com/smartcontractkit/mcms/sdk/solana"
 	mcmstypes "github.com/smartcontractkit/mcms/types"
 
@@ -94,6 +96,10 @@ func (tw *WorkerSolana) getTransactionsInBatchOperation(
 				IsSigner:   account.IsSigner,
 			})
 		}
+		accountsStr := strings.Join(lo.Map(instruction.Accounts, func(account timelockbindings.InstructionAccount, _ int) string {
+			return fmt.Sprintf("%s W:%t S:%t", account.Pubkey, account.IsWritable, account.IsSigner)
+		}), "\n  ")
+		tw.logger.Infof("OPERATIONS SOLANA - EXECUTE - ADDING TRANSACTION %d - ACCOUNTS:\n  %s\n", i, accountsStr)
 
 		marshaledAdditionalFields, err := json.Marshal(additionalFields)
 		if err != nil {

tests/integration/solana/compile-timelock-programs.sh

@@ -45,7 +45,7 @@ if [[ -z "$COMMIT_HASH" ]]; then
 fi
 
 # Programs to build
-PROGRAMS=("mcm" "timelock" "access-controller" "external-program-cpi-stub")
+PROGRAMS=("mcm" "timelock" "access-controller" "external-program-cpi-stub" "rmn-remote")
 
 cd "${PROJECT_ROOT}"
 

tests/integration/solana/config.toml

@@ -10,3 +10,4 @@ timelock = "DoajfR5tK24xVw51fWcawUZWhAXD8yrBJVacc13neVQA"
 mcm = "5vNJx78mz7KVMjhuipyr9jKBKcMrKYGdjGkgE4LUmjKk"
 external_program_cpi_stub = "2zZwzyptLqwFJFEFxjPvrdhiGpH9pJ3MfrrmZX6NTKxm"
 access_controller = "6KsN58MTnRQ8FfPaXHiFPPFGDRioikj9CdPvPxZJdCjb"
+rmn_remote = "RmnXLft1mSEwDgMKu2okYuHkiazxntFFcZFrrcXxYg7"

tests/integration/solana/suite.go

@@ -36,6 +36,7 @@ type solanaIntegrationTestSuite struct {
 	McmProgramID              solana.PublicKey
 	TimelockProgramID         solana.PublicKey
 	StubProgramID             solana.PublicKey
+	RmnRemoteProgramID        solana.PublicKey
 	AccessControllerProgramID solana.PublicKey
 	RoleMap                   timelockutils.RoleMap
 	ProposerAccessController  solana.PublicKey
@@ -70,6 +71,7 @@ func (s *solanaIntegrationTestSuite) SetupSuite() {
 	s.McmProgramID = solana.MustPublicKeyFromBase58(in.SolanaChain.SolanaPrograms["mcm"])
 	s.TimelockProgramID = solana.MustPublicKeyFromBase58(in.SolanaChain.SolanaPrograms["timelock"])
 	s.StubProgramID = solana.MustPublicKeyFromBase58(in.SolanaChain.SolanaPrograms["external_program_cpi_stub"])
+	s.RmnRemoteProgramID = solana.MustPublicKeyFromBase58(in.SolanaChain.SolanaPrograms["rmn_remote"])
 	s.AccessControllerProgramID = solana.MustPublicKeyFromBase58(in.SolanaChain.SolanaPrograms["access_controller"])
 	s.TestPrivateKey = solana.MustPrivateKeyFromBase58(privateKey)
 }

tests/integration/solana/utils.go

@@ -2,6 +2,7 @@ package solana
 
 import (
 	"context"
+	"crypto/ecdsa"
 	"fmt"
 	"testing"
 	"time"
@@ -21,16 +22,60 @@ import (
 	"github.com/smartcontractkit/chainlink-ccip/chains/solana/gobindings/access_controller"
 	cpistubbindings "github.com/smartcontractkit/chainlink-ccip/chains/solana/gobindings/external_program_cpi_stub"
 	mcmbindings "github.com/smartcontractkit/chainlink-ccip/chains/solana/gobindings/mcm"
+	rmnremotebindings "github.com/smartcontractkit/chainlink-ccip/chains/solana/gobindings/rmn_remote"
 	timelockbindings "github.com/smartcontractkit/chainlink-ccip/chains/solana/gobindings/timelock"
 	"github.com/smartcontractkit/chainlink-ccip/chains/solana/utils/accesscontroller"
 	"github.com/smartcontractkit/chainlink-ccip/chains/solana/utils/common"
 	timelockutils "github.com/smartcontractkit/chainlink-ccip/chains/solana/utils/timelock"
+	"github.com/smartcontractkit/mcms"
+	mcmssdk "github.com/smartcontractkit/mcms/sdk"
 	solanasdk "github.com/smartcontractkit/mcms/sdk/solana"
 	mcmstypes "github.com/smartcontractkit/mcms/types"
 
 	"github.com/smartcontractkit/timelock-worker/pkg/timelock"
+	evmtests "github.com/smartcontractkit/timelock-worker/tests/integration/evm"
 )
 
+var	solChainSelector = mcmstypes.ChainSelector(chainsel.SOLANA_DEVNET.Selector)
+
+func (s *solanaIntegrationTestSuite) scheduleProposal(
+	proposal *mcms.TimelockProposal, signerKey *ecdsa.PrivateKey, auth solana.PrivateKey,
+) {
+	converters := map[mcmstypes.ChainSelector]mcmssdk.TimelockConverter{solChainSelector: solanasdk.TimelockConverter{}}
+	mcmProposal, _, err := proposal.Convert(s.Ctx, converters)
+	s.Require().NoError(err)
+
+	inspectors := map[mcmstypes.ChainSelector]mcmssdk.Inspector{solChainSelector: solanasdk.NewInspector(s.solanaClient)}
+	encoders, err := mcmProposal.GetEncoders()
+	s.Require().NoError(err)
+	encoder := encoders[solChainSelector]
+	executor := solanasdk.NewExecutor(encoder.(*solanasdk.Encoder), s.solanaClient, auth)
+	executors := map[mcmstypes.ChainSelector]mcmssdk.Executor{solChainSelector: executor}
+
+	signable, err := mcms.NewSignable(&mcmProposal, inspectors)
+	s.Require().NoError(err)
+	s.Require().NotNil(signable)
+	_, err = signable.SignAndAppend(mcms.NewPrivateKeySigner(signerKey))
+	s.Require().NoError(err)
+
+	executable, err := mcms.NewExecutable(&mcmProposal, executors)
+	s.Require().NoError(err)
+
+	signature, err := executable.SetRoot(s.Ctx, solChainSelector)
+	s.Require().NoError(err)
+	_, err = solana.SignatureFromBase58(signature.Hash)
+	s.Require().NoError(err)
+	s.Logf("mcm.SetRoot()")
+
+	for i := range mcmProposal.Operations {
+		s.Logf("mcm.Execute(%d)", i)
+		signature, err = executable.Execute(s.Ctx, i)
+		s.Require().NoError(err)
+		_, err = solana.SignatureFromBase58(signature.Hash)
+		s.Require().NoError(err)
+	}
+}
+
 // getBatchAddAccessIxs returns a slice of instructions to batch add access for multiple addresses to a specific role in the Solana timelock instance.
 func (s *solanaIntegrationTestSuite) getBatchAddAccessIxs(
 	ctx context.Context, timelockID [32]byte, roleAcAccount solana.PublicKey, role timelockbindings.Role,
@@ -70,14 +115,13 @@ func (s *solanaIntegrationTestSuite) getBatchAddAccessIxs(
 	return ixs
 }
 
-// AssignRoleToAccounts assigns the specified role to the provided accounts in the Solana timelock instance.
-func (s *solanaIntegrationTestSuite) AssignRoleToAccounts(
-	ctx context.Context, pdaSeed solanasdk.PDASeed, auth solana.PrivateKey,
-	accounts []solana.PublicKey, role timelockbindings.Role,
+// assignRoleToAccounts assigns the specified role to the provided accounts in the Solana timelock instance.
+func (s *solanaIntegrationTestSuite) assignRoleToAccounts(
+	pdaSeed solanasdk.PDASeed, accounts []solana.PublicKey, role timelockbindings.Role,
 ) {
-	instructions := s.getBatchAddAccessIxs(ctx, pdaSeed, s.RoleMap[role].AccessController.PublicKey(),
-		role, accounts, auth, 1)
-	testutils.SendAndConfirm(ctx, s.T(), s.solanaClient, instructions, auth, rpc.CommitmentConfirmed)
+	instructions := s.getBatchAddAccessIxs(s.Ctx, pdaSeed, s.RoleMap[role].AccessController.PublicKey(),
+		role, accounts, s.TestPrivateKey, 1)
+	testutils.SendAndConfirm(s.Ctx, s.T(), s.solanaClient, instructions, s.TestPrivateKey, rpc.CommitmentConfirmed)
 }
 
 func (s *solanaIntegrationTestSuite) initializeAccessController(auth solana.PrivateKey) {
@@ -108,17 +152,6 @@ func (s *solanaIntegrationTestSuite) initializeTimelock(pdaSeed solanasdk.PDASee
 	s.initializeAccessController(admin)
 
 	s.Run("init timelock", func() {
-		data, accErr := s.solanaClient.GetAccountInfoWithOpts(s.Ctx, s.TimelockProgramID, &rpc.GetAccountInfoOpts{
-			Commitment: rpc.CommitmentConfirmed,
-		})
-		s.Require().NoError(accErr)
-
-		var programData struct {
-			DataType uint32
-			Address  solana.PublicKey
-		}
-		s.Require().NoError(bin.UnmarshalBorsh(&programData, data.Bytes()))
-
 		configPDA, err2 := solanasdk.FindTimelockConfigPDA(s.TimelockProgramID, pdaSeed)
 		s.Require().NoError(err2)
 
@@ -129,7 +162,7 @@ func (s *solanaIntegrationTestSuite) initializeTimelock(pdaSeed solanasdk.PDASee
 			admin.PublicKey(),
 			solana.SystemProgramID,
 			s.TimelockProgramID,
-			programData.Address,
+			s.getProgramDataAddress(s.TimelockProgramID),
 			s.AccessControllerProgramID,
 			s.ProposerAccessController,
 			s.ExecutorAccessController,
@@ -159,7 +192,7 @@ func (s *solanaIntegrationTestSuite) initializeTimelock(pdaSeed solanasdk.PDASee
 				accounts = append(accounts, account.PublicKey())
 			}
 
-			s.AssignRoleToAccounts(s.Ctx, pdaSeed, admin, accounts, roleAccounts.Role)
+			s.assignRoleToAccounts(pdaSeed, accounts, roleAccounts.Role)
 
 			for _, account := range roleAccounts.Accounts {
 				found, err := accesscontroller.HasAccess(s.Ctx, s.solanaClient, roleAccounts.AccessController.PublicKey(),
@@ -185,18 +218,8 @@ func (s *solanaIntegrationTestSuite) initializeMcm(pdaSeed [32]byte, signer eth.
 	s.Require().NoError(err)
 	chainSelector := chainsel.SOLANA_DEVNET.Selector
 
-	var programData struct {
-		DataType uint32
-		Address  solana.PublicKey
-	}
-	data, err := s.solanaClient.GetAccountInfoWithOpts(s.Ctx, s.McmProgramID,
-		&rpc.GetAccountInfoOpts{Commitment: rpc.CommitmentConfirmed})
-	s.Require().NoError(err)
-	err = bin.UnmarshalBorsh(&programData, data.Bytes())
-	s.Require().NoError(err)
-
 	ix, err := mcmbindings.NewInitializeInstruction(chainSelector, pdaSeed, configPDA, auth.PublicKey(),
-		solana.SystemProgramID, s.McmProgramID, programData.Address, rootMetadataPDA,
+		solana.SystemProgramID, s.McmProgramID, s.getProgramDataAddress(s.McmProgramID), rootMetadataPDA,
 		expiringRootAndOpCountPDA).ValidateAndBuild()
 	s.Require().NoError(err)
 
@@ -238,7 +261,7 @@ func (s *solanaIntegrationTestSuite) getInitAccessControllersIxs(ctx context.Con
 	return ixs
 }
 
-func (s *solanaIntegrationTestSuite) setupCPIStub(ctx context.Context) {
+func (s *solanaIntegrationTestSuite) initializeCPIStub() {
 	cpistubbindings.SetProgramID(s.StubProgramID)
 
 	admin, err := solana.PrivateKeyFromBase58(privateKey)
@@ -251,8 +274,82 @@ func (s *solanaIntegrationTestSuite) setupCPIStub(ctx context.Context) {
 		ValidateAndBuild()
 	s.Require().NoError(err)
 
-	_, err = sendAndConfirm(ctx, s.T(), s.solanaClient, admin, []solana.Instruction{instruction})
+	_, err = sendAndConfirm(s.Ctx, s.T(), s.solanaClient, admin, []solana.Instruction{instruction})
+	s.Require().NoError(err)
+}
+
+func (s *solanaIntegrationTestSuite) initializeRmnRemote() {
+	rmnremotebindings.SetProgramID(s.RmnRemoteProgramID)
+
+	auth, err := solana.PrivateKeyFromBase58(privateKey)
+	s.Require().NoError(err)
+	configPDA, _, err := solana.FindProgramAddress([][]byte{[]byte("config")}, s.RmnRemoteProgramID)
+	s.Require().NoError(err)
+	cursesPDA, _, err := solana.FindProgramAddress([][]byte{[]byte("curses")}, s.RmnRemoteProgramID)
+	s.Require().NoError(err)
+	// s.Logf("ACCOUNTS:\n%v\n%v\n%v\n%v\n%v\n%v\n", configPDA, cursesPDA, auth.PublicKey(),
+	// 	solana.SystemProgramID, s.RmnRemoteProgramID, s.getProgramDataAddress(s.RmnRemoteProgramID))
+
+	instruction, err := rmnremotebindings.NewInitializeInstruction(configPDA, cursesPDA, auth.PublicKey(),
+		solana.SystemProgramID, s.RmnRemoteProgramID, s.getProgramDataAddress(s.RmnRemoteProgramID)).ValidateAndBuild()
+	s.Require().NoError(err)
+
+	_, err = sendAndConfirm(s.Ctx, s.T(), s.solanaClient, auth, []solana.Instruction{instruction})
+	s.Require().NoError(err)
+}
+
+func (s *solanaIntegrationTestSuite) transferOwnershipRmnRemote(seed solanasdk.PDASeed, signer evmtests.TestAccount) {
+	configPDA, _, err := solana.FindProgramAddress([][]byte{[]byte("config")}, s.RmnRemoteProgramID)
+	s.Require().NoError(err)
+	cursesPDA, _, err := solana.FindProgramAddress([][]byte{[]byte("curses")}, s.RmnRemoteProgramID)
+	s.Require().NoError(err)
+	timelockSignerPDA, err := solanasdk.FindTimelockSignerPDA(s.TimelockProgramID, seed)
+	s.Require().NoError(err)
+
+	transferInstruction, err := rmnremotebindings.NewTransferOwnershipInstruction(timelockSignerPDA, configPDA,
+		cursesPDA, s.TestPrivateKey.PublicKey()).ValidateAndBuild()
+	s.Require().NoError(err)
+
+	acceptInstruction, err := rmnremotebindings.NewAcceptOwnershipInstruction(configPDA,
+		timelockSignerPDA).ValidateAndBuild()
+	s.Require().NoError(err)
+
+	s.transferOwnership(transferInstruction, acceptInstruction, seed, signer)
+	s.Logf("transferred ownership of RMNRemote to timelock")
+}
+
+func (s *solanaIntegrationTestSuite) transferOwnership(
+	transferInstruction, acceptInstruction solana.Instruction, seed solanasdk.PDASeed, signer evmtests.TestAccount,
+) {
+	// --- transfer ---
+	_, err := sendAndConfirm(s.Ctx, s.T(), s.solanaClient, s.TestPrivateKey, []solana.Instruction{transferInstruction})
+	s.Require().NoError(err)
+
+	// --- accept ---
+	acceptOwnershipTransaction, err := solanasdk.NewTransactionFromInstruction(acceptInstruction, "", nil)
 	s.Require().NoError(err)
+
+	chainMetadata, err := solanasdk.NewChainMetadata(0, s.McmProgramID, seed, s.ProposerAccessController,
+		s.CancellerAccessController, s.BypasserAccessController)
+	s.Require().NoError(err)
+	timelockAddress := solanasdk.ContractAddress(s.TimelockProgramID, seed)
+
+	proposal, err := mcms.NewTimelockProposalBuilder().
+		SetValidUntil(uint32(2051222400)). // 2035-01-01T12:00:00 UTC
+		SetDescription("proposal to accept ownership").
+		SetOverridePreviousRoot(true).
+		SetVersion("v1").
+		SetAction(mcmstypes.TimelockActionBypass).
+		SetChainMetadata(map[mcmstypes.ChainSelector]mcmstypes.ChainMetadata{solChainSelector: chainMetadata}).
+		AddTimelockAddress(solChainSelector, timelockAddress).
+		AddOperation(mcmstypes.BatchOperation{
+			ChainSelector: solChainSelector,
+			Transactions:  []mcmstypes.Transaction{acceptOwnershipTransaction},
+		}).
+		Build()
+	s.Require().NoError(err)
+
+	s.scheduleProposal(proposal, signer.PrivateKey, s.TestPrivateKey)
 }
 
 // runTimelockWorkerSolana runs the Solana timelock worker with the provided parameters.
@@ -410,6 +507,21 @@ func (s *solanaIntegrationTestSuite) scheduleTestIx(
 	return ixStub, operationID
 }
 
+func (s *solanaIntegrationTestSuite) getProgramDataAddress(programID solana.PublicKey) solana.PublicKey {
+	opts := &rpc.GetAccountInfoOpts{Commitment: rpc.CommitmentConfirmed}
+	data, accErr := s.solanaClient.GetAccountInfoWithOpts(s.Ctx, programID, opts)
+	s.Require().NoError(accErr)
+
+	var programData struct {
+		DataType uint32
+		Address  solana.PublicKey
+	}
+	err := bin.UnmarshalBorsh(&programData, data.Bytes())
+	s.Require().NoError(err)
+
+	return programData.Address
+}
+
 func sendAndConfirm(
 	ctx context.Context, t *testing.T, client *rpc.Client, txPayer solana.PrivateKey, instructions []solana.Instruction,
 ) (solana.Signature, error) {