Updates to deploy CCIP Solana to staging

deployment/environment/memory/chain.go

@@ -40,7 +40,7 @@ type EVMChain struct {
 	Users       []*bind.TransactOpts
 }
 
-type SolanaChain struct {
+type SolanaChainConfig struct {
 	Client      *solRpc.Client
 	DeployerKey solana.PrivateKey
 	URL         string
@@ -87,17 +87,21 @@ func getTestSolanaChainSelectors() []uint64 {
 	return result
 }
 
-func generateSolanaKeypair(t testing.TB) (solana.PrivateKey, string, error) {
-	// Create a temporary directory that will be cleaned up after the test
-	tmpDir := t.TempDir()
-
+func GenerateSolanaKeypair(dir string) (solana.PrivateKey, error) {
 	privateKey, err := solana.NewRandomPrivateKey()
 	if err != nil {
-		return solana.PrivateKey{}, "", fmt.Errorf("failed to generate private key: %w", err)
+		return solana.PrivateKey{}, fmt.Errorf("failed to generate private key: %w", err)
 	}
 
 	// Convert private key bytes to JSON array
+<<<<<<< Updated upstream
 	privateKeyBytes := []byte(privateKey)
+=======
+	privateKeyBytes, err := base58.Decode(privateKey.String())
+	if err != nil {
+		return solana.PrivateKey{}, fmt.Errorf("failed to decode private key: %w", err)
+	}
+>>>>>>> Stashed changes
 
 	// Convert bytes to array of integers for JSON
 	intArray := make([]int, len(privateKeyBytes))
@@ -107,40 +111,44 @@ func generateSolanaKeypair(t testing.TB) (solana.PrivateKey, string, error) {
 
 	keypairJSON, err := json.Marshal(intArray)
 	if err != nil {
-		return solana.PrivateKey{}, "", fmt.Errorf("failed to marshal keypair: %w", err)
+		return solana.PrivateKey{}, fmt.Errorf("failed to marshal keypair: %w", err)
 	}
 
-	// Create the keypair file in the temporary directory
-	keypairPath := filepath.Join(tmpDir, "solana-keypair.json")
+	// Create the keypair file in the directory
+	keypairPath := filepath.Join(dir, "solana-keypair.json")
 	if err := os.WriteFile(keypairPath, keypairJSON, 0600); err != nil {
-		return solana.PrivateKey{}, "", fmt.Errorf("failed to write keypair to file: %w", err)
+		return solana.PrivateKey{}, fmt.Errorf("failed to write keypair to file: %w", err)
 	}
 
-	return privateKey, keypairPath, nil
+	return privateKey, nil
 }
 
-func GenerateChainsSol(t *testing.T, numChains int) map[uint64]SolanaChain {
+func GenerateChainsSol(t *testing.T, numChains int) map[uint64]SolanaChainConfig {
 	testSolanaChainSelectors := getTestSolanaChainSelectors()
 	if len(testSolanaChainSelectors) < numChains {
 		t.Fatalf("not enough test solana chain selectors available")
 	}
-	chains := make(map[uint64]SolanaChain)
+
+	// Create a temporary directory that will be cleaned up after the test
+	tmpDir := t.TempDir()
+
+	chains := make(map[uint64]SolanaChainConfig)
 	for i := 0; i < numChains; i++ {
 		chainID := testSolanaChainSelectors[i]
-		admin, keypairPath, err := generateSolanaKeypair(t)
+		admin, err := GenerateSolanaKeypair(tmpDir)
 		require.NoError(t, err)
 		url, wsURL, err := solChain(t, chainID, &admin)
 		require.NoError(t, err)
 		client := solRpc.New(url)
 		balance, err := client.GetBalance(context.Background(), admin.PublicKey(), solRpc.CommitmentConfirmed)
 		require.NoError(t, err)
 		require.NotEqual(t, 0, balance.Value) // auto funded 500000000.000000000 SOL
-		chains[chainID] = SolanaChain{
+		chains[chainID] = SolanaChainConfig{
 			Client:      client,
 			DeployerKey: admin,
 			URL:         url,
 			WSURL:       wsURL,
-			KeypairPath: keypairPath,
+			KeypairPath: tmpDir,
 		}
 	}
 	return chains

deployment/environment/memory/environment.go

@@ -82,7 +82,40 @@ func NewMemoryChains(t *testing.T, numChains int, numUsers int) (map[uint64]depl
 
 func NewMemoryChainsSol(t *testing.T, numChains int) map[uint64]deployment.SolChain {
 	mchains := GenerateChainsSol(t, numChains)
+<<<<<<< Updated upstream
 	return generateMemoryChainSol(mchains)
+=======
+
+	chains := make(map[uint64]deployment.SolChain)
+
+	for cid, chainConfig := range mchains {
+		chains[cid] = deployment.SolChain{
+			Selector:     cid,
+			Client:       chainConfig.Client,
+			DeployerKey:  &chainConfig.DeployerKey,
+			URL:          chainConfig.URL,
+			WSURL:        chainConfig.WSURL,
+			KeypairPath:  chainConfig.KeypairPath,
+			ProgramsPath: ProgramsPath,
+			Confirm: func(instructions []solana.Instruction, opts ...solCommomUtil.TxModifier) error {
+				_, err := solCommomUtil.SendAndConfirm(
+					context.Background(),
+					chainConfig.Client,
+					instructions,
+					chainConfig.DeployerKey,
+					solRpc.CommitmentConfirmed,
+					opts...,
+				)
+				if err != nil {
+					return err
+				}
+				return nil
+			},
+		}
+	}
+
+	return chains
+>>>>>>> Stashed changes
 }
 
 func NewMemoryChainsWithChainIDs(t *testing.T, chainIDs []uint64, numUsers int) (map[uint64]deployment.Chain, map[uint64][]*bind.TransactOpts) {
@@ -137,6 +170,7 @@ func generateMemoryChain(t *testing.T, inputs map[uint64]EVMChain) map[uint64]de
 	return chains
 }
 
+<<<<<<< Updated upstream
 func generateMemoryChainSol(inputs map[uint64]SolanaChain) map[uint64]deployment.SolChain {
 	chains := make(map[uint64]deployment.SolChain)
 	for cid, chain := range inputs {
@@ -161,6 +195,9 @@ func generateMemoryChainSol(inputs map[uint64]SolanaChain) map[uint64]deployment
 }
 
 func NewNodes(t *testing.T, logLevel zapcore.Level, chains map[uint64]deployment.Chain, solChains map[uint64]deployment.SolChain, numNodes, numBootstraps int, registryConfig deployment.CapabilityRegistryConfig) map[string]Node {
+=======
+func NewNodes(t *testing.T, logLevel zapcore.Level, chains map[uint64]deployment.Chain, numNodes, numBootstraps int, registryConfig deployment.CapabilityRegistryConfig) map[string]Node {
+>>>>>>> Stashed changes
 	nodesByPeerID := make(map[string]Node)
 	if numNodes+numBootstraps == 0 {
 		return nodesByPeerID