[DRAFT] Updated TestChainComponents to utilize ChainWriter

contracts/programs/contract-reader-interface/src/lib.rs

@@ -35,6 +35,9 @@ pub mod contract_reader_interface {
 #[derive(Accounts)]
 #[instruction(test_idx: u64)]
 pub struct Initialize<'info> {
+    #[account(mut)]
+    pub signer: Signer<'info>,
+
     // derived test PDA
     #[account(
         init,
@@ -44,9 +47,6 @@ pub struct Initialize<'info> {
         bump)]
     pub data: Account<'info, DataAccount>,
 
-    #[account(mut)]
-    pub signer: Signer<'info>,
-
     pub system_program: Program<'info, System>,
 }
 

integration-tests/relayinterface/chain_components_test.go

@@ -7,7 +7,6 @@ import (
 	"context"
 	"encoding/binary"
 	"encoding/json"
-	"io"
 	"os"
 	"path/filepath"
 	"sync"
@@ -17,15 +16,18 @@ import (
 	"github.com/gagliardetto/solana-go"
 	"github.com/gagliardetto/solana-go/rpc"
 	"github.com/gagliardetto/solana-go/rpc/ws"
-	"github.com/gagliardetto/solana-go/text"
+	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 
 	commoncodec "github.com/smartcontractkit/chainlink-common/pkg/codec"
+	commonconfig "github.com/smartcontractkit/chainlink-common/pkg/config"
 	"github.com/smartcontractkit/chainlink-common/pkg/logger"
 	commontestutils "github.com/smartcontractkit/chainlink-common/pkg/loop/testutils"
+	"github.com/smartcontractkit/chainlink-common/pkg/services/servicetest"
 	"github.com/smartcontractkit/chainlink-common/pkg/types"
 	. "github.com/smartcontractkit/chainlink-common/pkg/types/interfacetests" //nolint common practice to import test mods with .
 	"github.com/smartcontractkit/chainlink-common/pkg/types/query/primitives"
+	commonutils "github.com/smartcontractkit/chainlink-common/pkg/utils"
 	"github.com/smartcontractkit/chainlink-common/pkg/utils/tests"
 
 	"github.com/smartcontractkit/chainlink-solana/pkg/solana/codec"
@@ -34,7 +36,11 @@ import (
 	"github.com/smartcontractkit/chainlink-solana/integration-tests/solclient"
 	"github.com/smartcontractkit/chainlink-solana/integration-tests/utils"
 	"github.com/smartcontractkit/chainlink-solana/pkg/solana/chainreader"
+	"github.com/smartcontractkit/chainlink-solana/pkg/solana/chainwriter"
+	"github.com/smartcontractkit/chainlink-solana/pkg/solana/client"
 	"github.com/smartcontractkit/chainlink-solana/pkg/solana/config"
+	"github.com/smartcontractkit/chainlink-solana/pkg/solana/txm"
+	keyMocks "github.com/smartcontractkit/chainlink-solana/pkg/solana/txm/mocks"
 	solanautils "github.com/smartcontractkit/chainlink-solana/pkg/solana/utils"
 )
 
@@ -127,14 +133,17 @@ type SolanaChainComponentsInterfaceTesterHelper[T TestingT[T]] interface {
 	Context(t T) context.Context
 	Logger(t T) logger.Logger
 	GetJSONEncodedIDL(t T) []byte
-	CreateAccount(t T, value uint64) solana.PublicKey
+	CreateAccount(t T, it SolanaChainComponentsInterfaceTester[T], value uint64) solana.PublicKey
+	TXM() *txm.TxManager
+	SolanaClient() *client.Client
 }
 
 type SolanaChainComponentsInterfaceTester[T TestingT[T]] struct {
 	TestSelectionSupport
 	Helper               SolanaChainComponentsInterfaceTesterHelper[T]
 	cr                   *chainreader.SolanaChainReaderService
 	contractReaderConfig config.ContractReader
+	chainWriterConfig    chainwriter.ChainWriterConfig
 }
 
 func (it *SolanaChainComponentsInterfaceTester[T]) Setup(t T) {
@@ -173,6 +182,41 @@ func (it *SolanaChainComponentsInterfaceTester[T]) Setup(t T) {
 			},
 		},
 	}
+
+	it.chainWriterConfig = chainwriter.ChainWriterConfig{
+		Programs: map[string]chainwriter.ProgramConfig{
+			AnyContractName: {
+				IDL: string(it.Helper.GetJSONEncodedIDL(t)),
+				Methods: map[string]chainwriter.MethodConfig{
+					"initialize": {
+						FromAddress:        solana.MustPrivateKeyFromBase58(solclient.DefaultPrivateKeysSolValidator[1]).PublicKey().String(),
+						InputModifications: nil,
+						ChainSpecificName:  "initialize",
+						LookupTables:       chainwriter.LookupTables{},
+						Accounts: []chainwriter.Lookup{
+							chainwriter.PDALookups{
+								Name: "Account",
+								PublicKey: chainwriter.AccountConstant{
+									Name:    "ProgramID",
+									Address: programPubKey,
+								},
+								Seeds: []chainwriter.Seed{
+									{Static: []byte("data")},
+									{Dynamic: chainwriter.AccountLookup{
+										Name:     "TestIDX",
+										Location: "TestIdx",
+									}},
+								},
+								IsWritable: true,
+								IsSigner:   false,
+							},
+						},
+						DebugIDLocation: "",
+					},
+				},
+			},
+		},
+	}
 }
 
 func (it *SolanaChainComponentsInterfaceTester[T]) Name() string {
@@ -204,14 +248,18 @@ func (it *SolanaChainComponentsInterfaceTester[T]) GetContractReader(t T) types.
 }
 
 func (it *SolanaChainComponentsInterfaceTester[T]) GetContractWriter(t T) types.ContractWriter {
-	return nil
+	cw, err := chainwriter.NewSolanaChainWriterService(it.Helper.Logger(t), it.Helper.SolanaClient(), *it.Helper.TXM(), nil, it.chainWriterConfig)
+	require.NoError(t, err)
+
+	servicetest.Run(t, cw)
+	return cw
 }
 
 func (it *SolanaChainComponentsInterfaceTester[T]) GetBindings(t T) []types.BoundContract {
 	// Create a new account with fresh state for each test
 	return []types.BoundContract{
-		{Name: AnyContractName, Address: it.Helper.CreateAccount(t, AnyValueToReadWithoutAnArgument).String()},
-		{Name: AnySecondContractName, Address: it.Helper.CreateAccount(t, AnyDifferentValueToReadWithoutAnArgument).String()},
+		{Name: AnyContractName, Address: it.Helper.CreateAccount(t, *it, AnyValueToReadWithoutAnArgument).String()},
+		{Name: AnySecondContractName, Address: it.Helper.CreateAccount(t, *it, AnyDifferentValueToReadWithoutAnArgument).String()},
 	}
 }
 
@@ -234,6 +282,8 @@ type helper struct {
 	idlBts    []byte
 	nonce     uint64
 	nonceMu   sync.Mutex
+	txm       txm.TxManager
+	sc        *client.Client
 }
 
 func (h *helper) Init(t *testing.T) {
@@ -250,6 +300,27 @@ func (h *helper) Init(t *testing.T) {
 
 	solanautils.FundAccounts(t, []solana.PrivateKey{privateKey}, h.rpcClient)
 
+	cfg := config.NewDefault()
+	cfg.Chain.TxRetentionTimeout = commonconfig.MustNewDuration(10 * time.Minute)
+	solanaClient, err := client.NewClient(h.rpcURL, cfg, 5*time.Second, nil)
+	require.NoError(t, err)
+
+	h.sc = solanaClient
+
+	loader := commonutils.NewLazyLoad(func() (client.ReaderWriter, error) { return solanaClient, nil })
+	mkey := keyMocks.NewSimpleKeystore(t)
+	mkey.On("Sign", mock.Anything, privateKey.PublicKey().String(), mock.Anything).Return(func(_ context.Context, _ string, data []byte) []byte {
+		sig, _ := privateKey.Sign(data)
+		return sig[:]
+	}, nil)
+	lggr := logger.Test(t)
+
+	txm := txm.NewTxm("localnet", loader, nil, cfg, mkey, lggr)
+	err = txm.Start(tests.Context(t))
+	require.NoError(t, err)
+
+	h.txm = txm
+
 	pubkey, err := solana.PublicKeyFromBase58(programPubKey)
 	require.NoError(t, err)
 
@@ -261,6 +332,14 @@ func (h *helper) RPCClient() *chainreader.RPCClientWrapper {
 	return &chainreader.RPCClientWrapper{Client: h.rpcClient}
 }
 
+func (h *helper) TXM() *txm.TxManager {
+	return &h.txm
+}
+
+func (h *helper) SolanaClient() *client.Client {
+	return h.sc
+}
+
 func (h *helper) Context(t *testing.T) context.Context {
 	return tests.Context(t)
 }
@@ -292,7 +371,7 @@ func (h *helper) GetJSONEncodedIDL(t *testing.T) []byte {
 	return h.idlBts
 }
 
-func (h *helper) CreateAccount(t *testing.T, value uint64) solana.PublicKey {
+func (h *helper) CreateAccount(t *testing.T, it SolanaChainComponentsInterfaceTester[*testing.T], value uint64) solana.PublicKey {
 	t.Helper()
 
 	// avoid collisions in parallel tests
@@ -307,90 +386,35 @@ func (h *helper) CreateAccount(t *testing.T, value uint64) solana.PublicKey {
 	pubKey, _, err := solana.FindProgramAddress([][]byte{[]byte("data"), bts}, h.programID)
 	require.NoError(t, err)
 
-	// Getting the default localnet private key
-	privateKey, err := solana.PrivateKeyFromBase58(solclient.DefaultPrivateKeysSolValidator[1])
-	require.NoError(t, err)
-
-	h.runInitialize(t, nonce, value, pubKey, func(key solana.PublicKey) *solana.PrivateKey {
-		return &privateKey
-	}, privateKey.PublicKey())
+	h.runInitialize(t, it, nonce, value)
 
 	return pubKey
 }
 
+type InitializeArgs struct {
+	TestIdx uint64
+	Value   uint64
+}
+
 func (h *helper) runInitialize(
 	t *testing.T,
+	it SolanaChainComponentsInterfaceTester[*testing.T],
 	nonce uint64,
 	value uint64,
-	data solana.PublicKey,
-	signerFunc func(key solana.PublicKey) *solana.PrivateKey,
-	payer solana.PublicKey,
 ) {
 	t.Helper()
 
-	inst, err := contract.NewInitializeInstruction(nonce*value, value, data, payer, solana.SystemProgramID).ValidateAndBuild()
-	require.NoError(t, err)
+	cw := it.GetContractWriter(t)
 
-	h.sendInstruction(t, inst, signerFunc, payer)
-}
-
-func (h *helper) sendInstruction(
-	t *testing.T,
-	inst *contract.Instruction,
-	signerFunc func(key solana.PublicKey) *solana.PrivateKey,
-	payer solana.PublicKey,
-) {
-	t.Helper()
-
-	ctx := tests.Context(t)
-
-	recent, err := h.rpcClient.GetLatestBlockhash(ctx, rpc.CommitmentFinalized)
-	require.NoError(t, err)
-
-	tx, err := solana.NewTransaction(
-		[]solana.Instruction{
-			inst,
-		},
-		recent.Value.Blockhash,
-		solana.TransactionPayer(payer),
-	)
-	require.NoError(t, err)
-
-	_, err = tx.EncodeTree(text.NewTreeEncoder(io.Discard, "Initialize"))
-	require.NoError(t, err)
-
-	_, err = tx.Sign(signerFunc)
-	require.NoError(t, err)
-
-	sig, err := h.rpcClient.SendTransactionWithOpts(
-		ctx, tx,
-		rpc.TransactionOpts{
-			PreflightCommitment: rpc.CommitmentConfirmed,
-		},
-	)
-	require.NoError(t, err)
-
-	h.waitForTX(t, sig, rpc.CommitmentFinalized)
-}
-
-func (h *helper) waitForTX(t *testing.T, sig solana.Signature, commitment rpc.CommitmentType) {
-	t.Helper()
-
-	sub, err := h.wsClient.SignatureSubscribe(
-		sig,
-		commitment,
-	)
-	require.NoError(t, err)
+	args := InitializeArgs{
+		TestIdx: nonce * value,
+		Value:   value,
+	}
 
-	defer sub.Unsubscribe()
+	buf := make([]byte, 8)
+	binary.LittleEndian.PutUint64(buf, nonce*value)
 
-	res, err := sub.Recv()
-	require.NoError(t, err)
-
-	if res.Value.Err != nil {
-		t.Logf("transaction confirmation failed: %v", res.Value.Err)
-		t.FailNow()
-	}
+	SubmitTransactionToCW(t, &it, cw, "initialize", args, types.BoundContract{Name: AnyContractName, Address: h.programID.String()}, types.Finalized)
 }
 
 func mustUnmarshalIDL[T TestingT[T]](t T, rawIDL string) codec.IDL {