add support for record program in the client

Author: samkim-crypto

token/client/Cargo.toml

@@ -9,15 +9,17 @@ version = "0.11.0"
 
 [dependencies]
 async-trait = "0.1"
+bincode = "1.3.2"
+bytemuck = "1.16.1"
 curve25519-dalek = "3.2.1"
 futures = "0.3.30"
 futures-util = "0.3"
-solana-banks-interface = "2.0.0"
-solana-cli-output = { version = "2.0.0", optional = true }
-solana-program-test = "2.0.0"
-solana-rpc-client = "2.0.0"
-solana-rpc-client-api = "2.0.0"
-solana-sdk = "2.0.0"
+solana-banks-interface = "2.1.0"
+solana-cli-output = { version = "2.1.0", optional = true }
+solana-program-test = "2.1.0"
+solana-rpc-client = "2.1.0"
+solana-rpc-client-api = "2.1.0"
+solana-sdk = "2.1.0"
 # We never want the entrypoint for ATA, but we want the entrypoint for token when
 # testing token
 spl-associated-token-account = { version = "4.0.0", path = "../../associated-token-account/program", features = [
@@ -26,6 +28,7 @@ spl-associated-token-account = { version = "4.0.0", path = "../../associated-tok
 spl-memo = { version = "5.0", path = "../../memo/program", features = [
   "no-entrypoint",
 ] }
+spl-record = { version = "0.2.0", path = "../../record/program", features = ["no-entrypoint"] }
 spl-token = { version = "6.0", path = "../program", features = [
   "no-entrypoint",
 ] }

token/client/src/proof_generation.rs

@@ -6,6 +6,7 @@
 
 use {
     curve25519_dalek::scalar::Scalar,
+    solana_sdk::pubkey::Pubkey,
     spl_token_2022::{
         error::TokenError,
         extension::confidential_transfer::{
@@ -32,6 +33,11 @@ use {
     },
 };
 
+pub enum ProofAccount {
+    ContextAccount(Pubkey),
+    RecordAccount(Pubkey),
+}
+
 /// The main logic to create the five split proof data for a transfer with fee.
 #[allow(clippy::too_many_arguments)]
 pub fn transfer_with_fee_split_proof_data(

token/client/src/temp_client.rs

@@ -0,0 +1,130 @@
+/// Basic trait for sending transactions to validators
+pub trait SendTransaction {
+    type Output;
+}
+
+/// Basic trait for simulating transactions in a validator
+pub trait SimulateTransaction {
+    type SimulationOutput: SimulationResult;
+}
+
+/// Trait for the output of a simulation
+pub trait SimulationResult {
+    fn get_compute_units_consumed(&self) -> ProgramClientResult<u64>;
+}
+
+/// Extend basic `SendTransaction` trait with function `send` where client is
+/// `&mut BankClient`. Required for `ProgramBanksClient`.
+pub trait SendTransactionBanksClient: SendTransaction {
+    fn send<'a>(
+        &self,
+        client: &'a mut BanksClient,
+        transaction: Transaction,
+    ) -> BoxFuture<'a, ProgramClientResult<Self::Output>>;
+}
+
+/// Extends basic `SimulateTransaction` trait with function `simulation` where
+/// client is `&mut BanksClient`. Required for `ProgramBanksClient`.
+pub trait SimulateTransactionBanksClient: SimulateTransaction {
+    fn simulate<'a>(
+        &self,
+        client: &'a mut BanksClient,
+        transaction: Transaction,
+    ) -> BoxFuture<'a, ProgramClientResult<Self::SimulationOutput>>;
+}
+
+/// Send transaction to validator using `BanksClient::process_transaction`.
+#[derive(Debug, Clone, Copy, Default)]
+pub struct ProgramBanksClientProcessTransaction;
+
+impl SendTransaction for ProgramBanksClientProcessTransaction {
+    type Output = ();
+}
+
+impl SendTransactionBanksClient for ProgramBanksClientProcessTransaction {
+    fn send<'a>(
+        &self,
+        client: &'a mut BanksClient,
+        transaction: Transaction,
+    ) -> BoxFuture<'a, ProgramClientResult<Self::Output>> {
+        Box::pin(async move {
+            client
+                .process_transaction(transaction)
+                .await
+                .map_err(Into::into)
+        })
+    }
+}
+
+pub type ProgramClientError = Box<dyn std::error::Error + Send + Sync>;
+pub type ProgramClientResult<T> = Result<T, ProgramClientError>;
+
+/// Generic client interface for programs.
+#[async_trait]
+pub trait ProgramClient<ST>
+where
+    ST: SendTransaction + SimulateTransaction,
+{
+    async fn get_minimum_balance_for_rent_exemption(
+        &self,
+        data_len: usize,
+    ) -> ProgramClientResult<u64>;
+
+    async fn get_latest_blockhash(&self) -> ProgramClientResult<Hash>;
+
+    async fn send_transaction(&self, transaction: &Transaction) -> ProgramClientResult<ST::Output>;
+
+    async fn get_account(&self, address: Pubkey) -> ProgramClientResult<Option<Account>>;
+
+    async fn simulate_transaction(
+        &self,
+        transaction: &Transaction,
+    ) -> ProgramClientResult<ST::SimulationOutput>;
+}
+
+enum ProgramBanksClientContext {
+    Client(Arc<Mutex<BanksClient>>),
+    Context(Arc<Mutex<ProgramTestContext>>),
+}
+
+/// Program client for `BanksClient` from crate `solana-program-test`.
+pub struct ProgramBanksClient<ST> {
+    context: ProgramBanksClientContext,
+    send: ST,
+}
+
+impl<ST> fmt::Debug for ProgramBanksClient<ST> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ProgramBanksClient").finish()
+    }
+}
+
+impl<ST> ProgramBanksClient<ST> {
+    fn new(context: ProgramBanksClientContext, send: ST) -> Self {
+        Self { context, send }
+    }
+
+    pub fn new_from_client(client: Arc<Mutex<BanksClient>>, send: ST) -> Self {
+        Self::new(ProgramBanksClientContext::Client(client), send)
+    }
+
+    pub fn new_from_context(context: Arc<Mutex<ProgramTestContext>>, send: ST) -> Self {
+        Self::new(ProgramBanksClientContext::Context(context), send)
+    }
+
+    async fn run_in_lock<F, O>(&self, f: F) -> O
+    where
+        for<'a> F: Fn(&'a mut BanksClient) -> BoxFuture<'a, O>,
+    {
+        match &self.context {
+            ProgramBanksClientContext::Client(client) => {
+                let mut lock = client.lock().await;
+                f(&mut lock).await
+            }
+            ProgramBanksClientContext::Context(context) => {
+                let mut lock = context.lock().await;
+                f(&mut lock.banks_client).await
+            }
+        }
+    }
+}