stash

Author: ananas-block

Cargo.lock

@@ -4,7 +4,7 @@ use crate::error::AccountError;
 
 /// Trait to abstract over different AccountInfo implementations (pinocchio vs solana)
 pub trait AccountInfoTrait {
-    type Pubkey: Copy + Clone;
+    type Pubkey: Copy + Clone + std::fmt::Debug;
     type DataRef<'a>: Deref<Target = [u8]>
     where
         Self: 'a;

program-libs/account-checks/src/account_info/account_info_trait.rs

@@ -77,7 +77,8 @@ pub mod system_cpi_test {
         } else {
             use light_sdk::cpi::CpiAccounts;
             let cpi_accounts =
-                CpiAccounts::new_with_config(&fee_payer, ctx.remaining_accounts, config);
+                CpiAccounts::try_new_with_config(&fee_payer, ctx.remaining_accounts, config)
+                    .unwrap();
             let account_infos = cpi_accounts.to_account_infos();
 
             let account_metas =

program-tests/create-address-test-program/src/lib.rs

@@ -26,6 +26,7 @@ light-sdk = { workspace = true }
 light-sdk-types = { workspace = true }
 light-compressed-account = { workspace = true }
 arrayvec = { workspace = true }
+light-batched-merkle-tree = { workspace = true }
 
 [dev-dependencies]
 light-program-test = { workspace = true, features = ["devenv"] }

program-tests/sdk-token-test/Cargo.toml

@@ -10,7 +10,9 @@ mod process_compress_tokens;
 mod process_create_compressed_account;
 mod process_decompress_tokens;
 mod process_transfer_tokens;
+mod process_update_depost;
 
+use light_sdk::{cpi::CpiAccounts, instruction::account_meta::CompressedAccountMeta};
 use process_batch_compress_tokens::process_batch_compress_tokens;
 use process_compress_tokens::process_compress_tokens;
 use process_create_compressed_account::process_create_compressed_account;
@@ -26,10 +28,14 @@ pub const LIGHT_CPI_SIGNER: CpiSigner =
 
 #[program]
 pub mod sdk_token_test {
-    use light_sdk::cpi::CpiAccounts;
+    use anchor_lang::solana_program::pubkey;
+    use light_sdk::address::v1::derive_address;
     use light_sdk_types::CpiAccountsConfig;
 
-    use crate::process_create_compressed_account::deposit_tokens;
+    use crate::{
+        process_create_compressed_account::deposit_tokens,
+        process_update_depost::{deposit_additional_tokens, process_update_escrow_pda},
+    };
 
     use super::*;
 
@@ -88,8 +94,8 @@ pub mod sdk_token_test {
         deposit_amount: u64,
         token_metas: Vec<TokenAccountMeta>,
         mint: Pubkey,
-        recipient: Pubkey,
         system_accounts_start_offset: u8,
+        recipient_bump: u8,
     ) -> Result<()> {
         // It makes sense to parse accounts once.
         let config = CpiAccountsConfig {
@@ -100,30 +106,124 @@ pub mod sdk_token_test {
             sol_pool_pda: false,
             sol_compression_recipient: false,
         };
-        let (token_account_infos, system_account_infos) = ctx
+        let (_, system_account_infos) = ctx
             .remaining_accounts
             .split_at(system_accounts_start_offset as usize);
         // Could add with pre account infos Option<u8>
-        let light_cpi_accounts = CpiAccounts::new_with_config(
+        let light_cpi_accounts = CpiAccounts::try_new_with_config(
             ctx.accounts.signer.as_ref(),
             system_account_infos,
             config,
+        )
+        .unwrap();
+        let (address, address_seed) = derive_address(
+            &[
+                b"escrow",
+                light_cpi_accounts.fee_payer().key.to_bytes().as_ref(),
+            ],
+            &address_tree_info
+                .get_tree_pubkey(&light_cpi_accounts)
+                .map_err(|_| ErrorCode::AccountNotEnoughKeys)?,
+            &crate::ID,
         );
+        msg!("seeds: {:?}", b"escrow");
+        msg!("seeds: {:?}", address);
+        msg!("recipient_bump: {:?}", recipient_bump);
+        let recipient = Pubkey::create_program_address(
+            &[b"escrow", &address, &[recipient_bump]],
+            ctx.program_id,
+        )
+        .unwrap();
         deposit_tokens(
             &light_cpi_accounts,
             token_metas,
             output_tree_index,
             mint,
             recipient,
             deposit_amount,
-            token_account_infos,
+            ctx.remaining_accounts,
         )?;
+        let new_address_params = address_tree_info.into_new_address_params_packed(address_seed);
+
         process_create_compressed_account(
             light_cpi_accounts,
             proof,
-            address_tree_info,
             output_tree_index,
             deposit_amount,
+            address,
+            new_address_params,
+        )
+    }
+
+    pub fn update_deposit<'info>(
+        ctx: Context<'_, '_, '_, 'info, GenericWithAuthority<'info>>,
+        proof: LightValidityProof,
+        output_tree_index: u8,
+        output_tree_queue_index: u8,
+        deposit_amount: u64,
+        depositing_token_metas: Vec<TokenAccountMeta>,
+        mint: Pubkey,
+        escrowed_token_meta: TokenAccountMeta,
+        system_accounts_start_offset: u8,
+        account_meta: CompressedAccountMeta,
+        existing_amount: u64,
+        recipient_bump: u8,
+    ) -> Result<()> {
+        // It makes sense to parse accounts once.
+        let config = CpiAccountsConfig {
+            cpi_signer: crate::LIGHT_CPI_SIGNER,
+            // TODO: add sanity check that account is a cpi context account.
+            cpi_context: true,
+            // TODO: add sanity check that account is a sol_pool_pda account.
+            sol_pool_pda: false,
+            sol_compression_recipient: false,
+        };
+        msg!(
+            "crate::LIGHT_CPI_SIGNER, {:?}",
+            anchor_lang::prelude::Pubkey::new_from_array(crate::LIGHT_CPI_SIGNER.cpi_signer)
+        );
+        msg!(
+            "system_accounts_start_offset {}",
+            system_accounts_start_offset
+        );
+        let (token_account_infos, system_account_infos) = ctx
+            .remaining_accounts
+            .split_at(system_accounts_start_offset as usize);
+        msg!("token_account_infos: {:?}", token_account_infos);
+        msg!("system_account_infos: {:?}", system_account_infos);
+        // TODO: figure out why the offsets are wrong.
+        // Could add with pre account infos Option<u8>
+        let light_cpi_accounts = CpiAccounts::try_new_with_config(
+            ctx.accounts.signer.as_ref(),
+            system_account_infos,
+            config,
+        )
+        .unwrap();
+        msg!(
+            "light_cpi_accounts {:?}",
+            light_cpi_accounts.authority().unwrap()
+        );
+        let recipient = ctx.accounts.authority.key();
+        deposit_additional_tokens(
+            &light_cpi_accounts,
+            depositing_token_metas,
+            escrowed_token_meta,
+            output_tree_index,
+            output_tree_queue_index,
+            mint,
+            recipient,
+            recipient_bump,
+            deposit_amount,
+            account_meta.address,
+            ctx.remaining_accounts,
+            ctx.accounts.authority.to_account_info(),
+        )?;
+        process_update_escrow_pda(
+            light_cpi_accounts,
+            account_meta,
+            proof,
+            existing_amount,
+            deposit_amount,
         )
     }
 }
@@ -134,3 +234,11 @@ pub struct Generic<'info> {
     #[account(mut)]
     pub signer: Signer<'info>,
 }
+
+#[derive(Accounts)]
+pub struct GenericWithAuthority<'info> {
+    // fee payer and authority are the same
+    #[account(mut)]
+    pub signer: Signer<'info>,
+    pub authority: AccountInfo<'info>,
+}

program-tests/sdk-token-test/src/lib.rs

@@ -11,7 +11,7 @@ use light_compressed_token_sdk::{
 };
 use light_sdk::{
     account::LightAccount,
-    address::v1::derive_address,
+    address::{v1::derive_address, NewAddressParams},
     cpi::{CpiAccounts, CpiInputs},
     instruction::{PackedAddressTreeInfo, ValidityProof},
     light_account_checks::AccountInfoTrait,
@@ -29,19 +29,11 @@ pub struct MyTokenCompressedAccount {
 pub fn process_create_compressed_account(
     cpi_accounts: CpiAccounts,
     proof: ValidityProof,
-    address_tree_info: PackedAddressTreeInfo,
     output_tree_index: u8,
     amount: u64,
+    address: [u8; 32],
+    new_address_params: light_sdk::address::PackedNewAddressParams,
 ) -> Result<()> {
-    let (address, address_seed) = derive_address(
-        &[b"deposit", cpi_accounts.fee_payer().key.to_bytes().as_ref()],
-        &address_tree_info
-            .get_tree_pubkey(&cpi_accounts)
-            .map_err(|_| ErrorCode::AccountNotEnoughKeys)?,
-        &crate::ID,
-    );
-    let new_address_params = address_tree_info.into_new_address_params_packed(address_seed);
-
     let mut my_compressed_account = LightAccount::<'_, MyTokenCompressedAccount>::new_init(
         &crate::ID,
         Some(address),
@@ -82,7 +74,7 @@ pub fn deposit_tokens<'info>(
     mint: Pubkey,
     recipient: Pubkey,
     amount: u64,
-    token_account_infos: &[AccountInfo<'info>],
+    remaining_accounts: &[AccountInfo<'info>],
 ) -> Result<()> {
     let sender_account = CTokenAccount::new(
         mint,
@@ -94,14 +86,14 @@ pub fn deposit_tokens<'info>(
     // We need to be careful what accounts we pass.
     // Big accounts cost many CU.
     // TODO: replace
-    let tree_account_infos =
-        filter_packed_accounts(&[&sender_account], cpi_accounts.tree_accounts().unwrap());
+    let tree_account_infos = cpi_accounts.tree_accounts().unwrap();
+    let tree_account_len = tree_account_infos.len();
+    // skip cpi context account and omit the address tree and queue accounts.
+    let tree_account_infos = &tree_account_infos[1..tree_account_len - 2];
     let tree_pubkeys = tree_account_infos
         .iter()
         .map(|x| x.pubkey())
         .collect::<Vec<Pubkey>>();
-    // msg!("tree_pubkeys {:?}", tree_pubkeys);
-    let cpi_context = cpi_accounts.cpi_context().unwrap();
     let cpi_context_pubkey = *cpi_accounts.cpi_context().unwrap().key;
     // msg!("cpi_context_pubkey {:?}", cpi_context_pubkey);
     let transfer_inputs = TransferInputs {
@@ -133,16 +125,22 @@ pub fn deposit_tokens<'info>(
     msg!("create_account_infos");
     sol_log_compute_units();
     // TODO: initialize from CpiAccounts, use with_compressed_pda() offchain.
-    let account_infos: TransferAccountInfos<'_, 'info, MAX_ACCOUNT_INFOS> = TransferAccountInfos {
-        fee_payer: cpi_accounts.fee_payer(),
-        authority: cpi_accounts.fee_payer(),
-        packed_accounts: tree_account_infos.as_slice(),
-        ctoken_accounts: token_account_infos,
-        cpi_context: Some(cpi_context),
-    };
-    let account_infos = account_infos.into_account_infos();
+    // let account_infos: TransferAccountInfos<'_, 'info, MAX_ACCOUNT_INFOS> = TransferAccountInfos {
+    //     fee_payer: cpi_accounts.fee_payer(),
+    //     authority: cpi_accounts.fee_payer(),
+    //     packed_accounts: tree_account_infos.as_slice(),
+    //     ctoken_accounts: token_account_infos,
+    //     cpi_context: Some(cpi_context),
+    // };
+    // let account_infos = account_infos.into_account_infos();
+    // We can remove the address Merkle tree accounts.
+    let len = remaining_accounts.len() - 2;
     // into_account_infos_checked() can be used for debugging but doubles CU cost to 1.5k CU
-
+    let account_infos = [
+        &[cpi_accounts.fee_payer().clone()][..],
+        &remaining_accounts[..len],
+    ]
+    .concat();
     sol_log_compute_units();
 
     sol_log_compute_units();