Merge branch 'main' into Pravdyvy/indexer-state-management

integration_tests/tests/amm.rs

@@ -102,7 +102,7 @@ async fn amm_public() -> Result<()> {
         from: format_public_account_id(supply_account_id_1),
         to: Some(format_public_account_id(recipient_account_id_1)),
         to_npk: None,
-        to_ipk: None,
+        to_vpk: None,
         amount: 7,
     };
 
@@ -126,7 +126,7 @@ async fn amm_public() -> Result<()> {
         from: format_public_account_id(supply_account_id_2),
         to: Some(format_public_account_id(recipient_account_id_2)),
         to_npk: None,
-        to_ipk: None,
+        to_vpk: None,
         amount: 7,
     };
 

integration_tests/tests/auth_transfer/private.rs

@@ -26,7 +26,7 @@ async fn private_transfer_to_owned_account() -> Result<()> {
         from: format_private_account_id(from),
         to: Some(format_private_account_id(to)),
         to_npk: None,
-        to_ipk: None,
+        to_vpk: None,
         amount: 100,
     });
 
@@ -59,13 +59,13 @@ async fn private_transfer_to_foreign_account() -> Result<()> {
     let from: AccountId = ctx.existing_private_accounts()[0];
     let to_npk = NullifierPublicKey([42; 32]);
     let to_npk_string = hex::encode(to_npk.0);
-    let to_ipk = Secp256k1Point::from_scalar(to_npk.0);
+    let to_vpk = Secp256k1Point::from_scalar(to_npk.0);
 
     let command = Command::AuthTransfer(AuthTransferSubcommand::Send {
         from: format_private_account_id(from),
         to: None,
         to_npk: Some(to_npk_string),
-        to_ipk: Some(hex::encode(to_ipk.0)),
+        to_vpk: Some(hex::encode(to_vpk.0)),
         amount: 100,
     });
 
@@ -113,7 +113,7 @@ async fn deshielded_transfer_to_public_account() -> Result<()> {
         from: format_private_account_id(from),
         to: Some(format_public_account_id(to)),
         to_npk: None,
-        to_ipk: None,
+        to_vpk: None,
         amount: 100,
     });
 
@@ -168,12 +168,12 @@ async fn private_transfer_to_owned_account_using_claiming_path() -> Result<()> {
         .cloned()
         .context("Failed to get private account")?;
 
-    // Send to this account using claiming path (using npk and ipk instead of account ID)
+    // Send to this account using claiming path (using npk and vpk instead of account ID)
     let command = Command::AuthTransfer(AuthTransferSubcommand::Send {
         from: format_private_account_id(from),
         to: None,
         to_npk: Some(hex::encode(to_keys.nullifer_public_key.0)),
-        to_ipk: Some(hex::encode(to_keys.incoming_viewing_public_key.0)),
+        to_vpk: Some(hex::encode(to_keys.viewing_public_key.0)),
         amount: 100,
     });
 
@@ -221,7 +221,7 @@ async fn shielded_transfer_to_owned_private_account() -> Result<()> {
         from: format_public_account_id(from),
         to: Some(format_private_account_id(to)),
         to_npk: None,
-        to_ipk: None,
+        to_vpk: None,
         amount: 100,
     });
 
@@ -256,14 +256,14 @@ async fn shielded_transfer_to_foreign_account() -> Result<()> {
 
     let to_npk = NullifierPublicKey([42; 32]);
     let to_npk_string = hex::encode(to_npk.0);
-    let to_ipk = Secp256k1Point::from_scalar(to_npk.0);
+    let to_vpk = Secp256k1Point::from_scalar(to_npk.0);
     let from: AccountId = ctx.existing_public_accounts()[0];
 
     let command = Command::AuthTransfer(AuthTransferSubcommand::Send {
         from: format_public_account_id(from),
         to: None,
         to_npk: Some(to_npk_string),
-        to_ipk: Some(hex::encode(to_ipk.0)),
+        to_vpk: Some(hex::encode(to_vpk.0)),
         amount: 100,
     });
 
@@ -325,12 +325,12 @@ async fn private_transfer_to_owned_account_continuous_run_path() -> Result<()> {
         .cloned()
         .context("Failed to get private account")?;
 
-    // Send transfer using nullifier and incoming viewing public keys
+    // Send transfer using nullifier and  viewing public keys
     let command = Command::AuthTransfer(AuthTransferSubcommand::Send {
         from: format_private_account_id(from),
         to: None,
         to_npk: Some(hex::encode(to_keys.nullifer_public_key.0)),
-        to_ipk: Some(hex::encode(to_keys.incoming_viewing_public_key.0)),
+        to_vpk: Some(hex::encode(to_keys.viewing_public_key.0)),
         amount: 100,
     });
 

integration_tests/tests/auth_transfer/public.rs

@@ -19,7 +19,7 @@ async fn successful_transfer_to_existing_account() -> Result<()> {
         from: format_public_account_id(ctx.existing_public_accounts()[0]),
         to: Some(format_public_account_id(ctx.existing_public_accounts()[1])),
         to_npk: None,
-        to_ipk: None,
+        to_vpk: None,
         amount: 100,
     });
 
@@ -72,7 +72,7 @@ pub async fn successful_transfer_to_new_account() -> Result<()> {
         from: format_public_account_id(ctx.existing_public_accounts()[0]),
         to: Some(format_public_account_id(new_persistent_account_id)),
         to_npk: None,
-        to_ipk: None,
+        to_vpk: None,
         amount: 100,
     });
 
@@ -108,7 +108,7 @@ async fn failed_transfer_with_insufficient_balance() -> Result<()> {
         from: format_public_account_id(ctx.existing_public_accounts()[0]),
         to: Some(format_public_account_id(ctx.existing_public_accounts()[1])),
         to_npk: None,
-        to_ipk: None,
+        to_vpk: None,
         amount: 1000000,
     });
 
@@ -146,7 +146,7 @@ async fn two_consecutive_successful_transfers() -> Result<()> {
         from: format_public_account_id(ctx.existing_public_accounts()[0]),
         to: Some(format_public_account_id(ctx.existing_public_accounts()[1])),
         to_npk: None,
-        to_ipk: None,
+        to_vpk: None,
         amount: 100,
     });
 
@@ -178,7 +178,7 @@ async fn two_consecutive_successful_transfers() -> Result<()> {
         from: format_public_account_id(ctx.existing_public_accounts()[0]),
         to: Some(format_public_account_id(ctx.existing_public_accounts()[1])),
         to_npk: None,
-        to_ipk: None,
+        to_vpk: None,
         amount: 100,
     });
 

integration_tests/tests/indexer.rs

@@ -12,7 +12,7 @@ use tokio::test;
 use wallet::cli::{Command, programs::native_token_transfer::AuthTransferSubcommand};
 
 /// Timeout in milliseconds to reliably await for block finalization
-const L2_TO_L1_TIMEOUT_MILLIS: u64 = 220000;
+const L2_TO_L1_TIMEOUT_MILLIS: u64 = 300000;
 
 #[test]
 async fn indexer_test_run() -> Result<()> {
@@ -45,6 +45,7 @@ async fn indexer_test_run() -> Result<()> {
 }
 
 #[test]
+#[ignore = "Not reliable with current bedrock node"]
 async fn indexer_block_batching() -> Result<()> {
     let ctx = TestContext::new().await?;
 
@@ -80,6 +81,7 @@ async fn indexer_block_batching() -> Result<()> {
 }
 
 #[test]
+#[ignore = "Not reliable with current bedrock node"]
 async fn indexer_state_consistency() -> Result<()> {
     let mut ctx = TestContext::new().await?;
 
@@ -87,7 +89,7 @@ async fn indexer_state_consistency() -> Result<()> {
         from: format_public_account_id(ctx.existing_public_accounts()[0]),
         to: Some(format_public_account_id(ctx.existing_public_accounts()[1])),
         to_npk: None,
-        to_ipk: None,
+        to_vpk: None,
         amount: 100,
     });
 
@@ -119,7 +121,7 @@ async fn indexer_state_consistency() -> Result<()> {
         from: format_private_account_id(from),
         to: Some(format_private_account_id(to)),
         to_npk: None,
-        to_ipk: None,
+        to_vpk: None,
         amount: 100,
     });
 

integration_tests/tests/keys_restoration.rs

@@ -50,7 +50,7 @@ async fn restore_keys_from_seed() -> Result<()> {
         from: format_private_account_id(from),
         to: Some(format_private_account_id(to_account_id1)),
         to_npk: None,
-        to_ipk: None,
+        to_vpk: None,
         amount: 100,
     });
     wallet::cli::execute_subcommand(ctx.wallet_mut(), command).await?;
@@ -60,7 +60,7 @@ async fn restore_keys_from_seed() -> Result<()> {
         from: format_private_account_id(from),
         to: Some(format_private_account_id(to_account_id2)),
         to_npk: None,
-        to_ipk: None,
+        to_vpk: None,
         amount: 101,
     });
     wallet::cli::execute_subcommand(ctx.wallet_mut(), command).await?;
@@ -96,7 +96,7 @@ async fn restore_keys_from_seed() -> Result<()> {
         from: format_public_account_id(from),
         to: Some(format_public_account_id(to_account_id3)),
         to_npk: None,
-        to_ipk: None,
+        to_vpk: None,
         amount: 102,
     });
     wallet::cli::execute_subcommand(ctx.wallet_mut(), command).await?;
@@ -106,7 +106,7 @@ async fn restore_keys_from_seed() -> Result<()> {
         from: format_public_account_id(from),
         to: Some(format_public_account_id(to_account_id4)),
         to_npk: None,
-        to_ipk: None,
+        to_vpk: None,
         amount: 103,
     });
     wallet::cli::execute_subcommand(ctx.wallet_mut(), command).await?;
@@ -169,7 +169,7 @@ async fn restore_keys_from_seed() -> Result<()> {
         from: format_private_account_id(to_account_id1),
         to: Some(format_private_account_id(to_account_id2)),
         to_npk: None,
-        to_ipk: None,
+        to_vpk: None,
         amount: 10,
     });
     wallet::cli::execute_subcommand(ctx.wallet_mut(), command).await?;
@@ -178,7 +178,7 @@ async fn restore_keys_from_seed() -> Result<()> {
         from: format_public_account_id(to_account_id3),
         to: Some(format_public_account_id(to_account_id4)),
         to_npk: None,
-        to_ipk: None,
+        to_vpk: None,
         amount: 11,
     });
     wallet::cli::execute_subcommand(ctx.wallet_mut(), command).await?;

integration_tests/tests/token.rs

@@ -115,7 +115,7 @@ async fn create_and_transfer_public_token() -> Result<()> {
         from: format_public_account_id(supply_account_id),
         to: Some(format_public_account_id(recipient_account_id)),
         to_npk: None,
-        to_ipk: None,
+        to_vpk: None,
         amount: transfer_amount,
     };
 
@@ -208,7 +208,7 @@ async fn create_and_transfer_public_token() -> Result<()> {
         definition: format_public_account_id(definition_account_id),
         holder: Some(format_public_account_id(recipient_account_id)),
         holder_npk: None,
-        holder_ipk: None,
+        holder_vpk: None,
         amount: mint_amount,
     };
 
@@ -343,7 +343,7 @@ async fn create_and_transfer_token_with_private_supply() -> Result<()> {
         from: format_private_account_id(supply_account_id),
         to: Some(format_private_account_id(recipient_account_id)),
         to_npk: None,
-        to_ipk: None,
+        to_vpk: None,
         amount: transfer_amount,
     };
 
@@ -525,7 +525,7 @@ async fn create_token_with_private_definition() -> Result<()> {
         definition: format_private_account_id(definition_account_id),
         holder: Some(format_public_account_id(recipient_account_id_public)),
         holder_npk: None,
-        holder_ipk: None,
+        holder_vpk: None,
         amount: mint_amount_public,
     };
 
@@ -572,7 +572,7 @@ async fn create_token_with_private_definition() -> Result<()> {
         definition: format_private_account_id(definition_account_id),
         holder: Some(format_private_account_id(recipient_account_id_private)),
         holder_npk: None,
-        holder_ipk: None,
+        holder_vpk: None,
         amount: mint_amount_private,
     };
 
@@ -701,7 +701,7 @@ async fn create_token_with_private_definition_and_supply() -> Result<()> {
         from: format_private_account_id(supply_account_id),
         to: Some(format_private_account_id(recipient_account_id)),
         to_npk: None,
-        to_ipk: None,
+        to_vpk: None,
         amount: transfer_amount,
     };
 
@@ -819,7 +819,7 @@ async fn shielded_token_transfer() -> Result<()> {
         from: format_public_account_id(supply_account_id),
         to: Some(format_private_account_id(recipient_account_id)),
         to_npk: None,
-        to_ipk: None,
+        to_vpk: None,
         amount: transfer_amount,
     };
 
@@ -933,7 +933,7 @@ async fn deshielded_token_transfer() -> Result<()> {
         from: format_private_account_id(supply_account_id),
         to: Some(format_public_account_id(recipient_account_id)),
         to_npk: None,
-        to_ipk: None,
+        to_vpk: None,
         amount: transfer_amount,
     };
 
@@ -1056,7 +1056,7 @@ async fn token_claiming_path_with_private_accounts() -> Result<()> {
         definition: format_private_account_id(definition_account_id),
         holder: None,
         holder_npk: Some(hex::encode(holder_keys.nullifer_public_key.0)),
-        holder_ipk: Some(hex::encode(holder_keys.incoming_viewing_public_key.0)),
+        holder_vpk: Some(hex::encode(holder_keys.viewing_public_key.0)),
         amount: mint_amount,
     };
 

integration_tests/tests/tps.rs

@@ -16,7 +16,7 @@ use nssa::{
 use nssa_core::{
     MembershipProof, NullifierPublicKey,
     account::{AccountWithMetadata, data::Data},
-    encryption::IncomingViewingPublicKey,
+    encryption::ViewingPublicKey,
 };
 use tokio::test;
 
@@ -192,8 +192,8 @@ impl TpsTestManager {
 fn build_privacy_transaction() -> PrivacyPreservingTransaction {
     let program = Program::authenticated_transfer_program();
     let sender_nsk = [1; 32];
-    let sender_isk = [99; 32];
-    let sender_ipk = IncomingViewingPublicKey::from_scalar(sender_isk);
+    let sender_vsk = [99; 32];
+    let sender_vpk = ViewingPublicKey::from_scalar(sender_vsk);
     let sender_npk = NullifierPublicKey::from(&sender_nsk);
     let sender_pre = AccountWithMetadata::new(
         Account {
@@ -206,18 +206,18 @@ fn build_privacy_transaction() -> PrivacyPreservingTransaction {
         AccountId::from(&sender_npk),
     );
     let recipient_nsk = [2; 32];
-    let recipient_isk = [99; 32];
-    let recipient_ipk = IncomingViewingPublicKey::from_scalar(recipient_isk);
+    let recipient_vsk = [99; 32];
+    let recipient_vpk = ViewingPublicKey::from_scalar(recipient_vsk);
     let recipient_npk = NullifierPublicKey::from(&recipient_nsk);
     let recipient_pre =
         AccountWithMetadata::new(Account::default(), false, AccountId::from(&recipient_npk));
 
     let eph_holder_from = EphemeralKeyHolder::new(&sender_npk);
-    let sender_ss = eph_holder_from.calculate_shared_secret_sender(&sender_ipk);
+    let sender_ss = eph_holder_from.calculate_shared_secret_sender(&sender_vpk);
     let sender_epk = eph_holder_from.generate_ephemeral_public_key();
 
     let eph_holder_to = EphemeralKeyHolder::new(&recipient_npk);
-    let recipient_ss = eph_holder_to.calculate_shared_secret_sender(&recipient_ipk);
+    let recipient_ss = eph_holder_to.calculate_shared_secret_sender(&recipient_vpk);
     let recipient_epk = eph_holder_from.generate_ephemeral_public_key();
 
     let balance_to_move: u128 = 1;
@@ -246,8 +246,8 @@ fn build_privacy_transaction() -> PrivacyPreservingTransaction {
         vec![],
         vec![],
         vec![
-            (sender_npk, sender_ipk, sender_epk),
-            (recipient_npk, recipient_ipk, recipient_epk),
+            (sender_npk, sender_vpk, sender_epk),
+            (recipient_npk, recipient_vpk, recipient_epk),
         ],
         output,
     )

integration_tests/tests/wallet_ffi.rs

@@ -2,6 +2,7 @@ use std::{
     collections::HashSet,
     ffi::{CStr, CString, c_char},
     io::Write,
+    path::Path,
     time::Duration,
 };
 
@@ -24,6 +25,11 @@ unsafe extern "C" {
         password: *const c_char,
     ) -> *mut WalletHandle;
 
+    fn wallet_ffi_open(
+        config_path: *const c_char,
+        storage_path: *const c_char,
+    ) -> *mut WalletHandle;
+
     fn wallet_ffi_destroy(handle: *mut WalletHandle);
 
     fn wallet_ffi_create_account_public(
@@ -56,6 +62,12 @@ unsafe extern "C" {
         out_account: *mut FfiAccount,
     ) -> error::WalletFfiError;
 
+    fn wallet_ffi_get_account_private(
+        handle: *mut WalletHandle,
+        account_id: *const FfiBytes32,
+        out_account: *mut FfiAccount,
+    ) -> error::WalletFfiError;
+
     fn wallet_ffi_free_account_data(account: *mut FfiAccount);
 
     fn wallet_ffi_get_public_account_key(
@@ -89,6 +101,30 @@ unsafe extern "C" {
         out_result: *mut FfiTransferResult,
     ) -> error::WalletFfiError;
 
+    fn wallet_ffi_transfer_shielded(
+        handle: *mut WalletHandle,
+        from: *const FfiBytes32,
+        to_keys: *const FfiPrivateAccountKeys,
+        amount: *const [u8; 16],
+        out_result: *mut FfiTransferResult,
+    ) -> error::WalletFfiError;
+
+    fn wallet_ffi_transfer_deshielded(
+        handle: *mut WalletHandle,
+        from: *const FfiBytes32,
+        to: *const FfiBytes32,
+        amount: *const [u8; 16],
+        out_result: *mut FfiTransferResult,
+    ) -> error::WalletFfiError;
+
+    fn wallet_ffi_transfer_private(
+        handle: *mut WalletHandle,
+        from: *const FfiBytes32,
+        to_keys: *const FfiPrivateAccountKeys,
+        amount: *const [u8; 16],
+        out_result: *mut FfiTransferResult,
+    ) -> error::WalletFfiError;
+
     fn wallet_ffi_free_transfer_result(result: *mut FfiTransferResult);
 
     fn wallet_ffi_register_public_account(
@@ -96,12 +132,29 @@ unsafe extern "C" {
         account_id: *const FfiBytes32,
         out_result: *mut FfiTransferResult,
     ) -> error::WalletFfiError;
+
+    fn wallet_ffi_register_private_account(
+        handle: *mut WalletHandle,
+        account_id: *const FfiBytes32,
+        out_result: *mut FfiTransferResult,
+    ) -> error::WalletFfiError;
+
+    fn wallet_ffi_save(handle: *mut WalletHandle) -> error::WalletFfiError;
+
+    fn wallet_ffi_sync_to_block(handle: *mut WalletHandle, block_id: u64) -> error::WalletFfiError;
+
+    fn wallet_ffi_get_current_block_height(
+        handle: *mut WalletHandle,
+        out_block_height: *mut u64,
+    ) -> error::WalletFfiError;
 }
 
-fn new_wallet_ffi_with_test_context_config(ctx: &BlockingTestContext) -> *mut WalletHandle {
-    let tempdir = tempfile::tempdir().unwrap();
-    let config_path = tempdir.path().join("wallet_config.json");
-    let storage_path = tempdir.path().join("storage.json");
+fn new_wallet_ffi_with_test_context_config(
+    ctx: &BlockingTestContext,
+    home: &Path,
+) -> *mut WalletHandle {
+    let config_path = home.join("wallet_config.json");
+    let storage_path = home.join("storage.json");
     let mut config = ctx.ctx().wallet().config().to_owned();
     if let Some(config_overrides) = ctx.ctx().wallet().config_overrides().clone() {
         config.apply_overrides(config_overrides);
@@ -161,6 +214,15 @@ fn new_wallet_rust_with_default_config(password: &str) -> WalletCore {
     .unwrap()
 }
 
+fn load_existing_ffi_wallet(home: &Path) -> *mut WalletHandle {
+    let config_path = home.join("wallet_config.json");
+    let storage_path = home.join("storage.json");
+    let config_path = CString::new(config_path.to_str().unwrap()).unwrap();
+    let storage_path = CString::new(storage_path.to_str().unwrap()).unwrap();
+
+    unsafe { wallet_ffi_open(config_path.as_ptr(), storage_path.as_ptr()) }
+}
+
 #[test]
 fn test_wallet_ffi_create_public_accounts() {
     let password = "password_for_tests";
@@ -232,6 +294,56 @@ fn test_wallet_ffi_create_private_accounts() {
 
     assert_eq!(new_private_account_ids_ffi, new_private_account_ids_rust)
 }
+#[test]
+fn test_wallet_ffi_save_and_load_persistent_storage() -> Result<()> {
+    let ctx = BlockingTestContext::new()?;
+    let mut out_private_account_id = FfiBytes32::from_bytes([0; 32]);
+    let home = tempfile::tempdir().unwrap();
+
+    // Create a private account with the wallet FFI and save it
+    unsafe {
+        let wallet_ffi_handle = new_wallet_ffi_with_test_context_config(&ctx, home.path());
+        wallet_ffi_create_account_private(
+            wallet_ffi_handle,
+            (&mut out_private_account_id) as *mut FfiBytes32,
+        );
+
+        wallet_ffi_save(wallet_ffi_handle);
+        wallet_ffi_destroy(wallet_ffi_handle);
+    }
+
+    let private_account_keys = unsafe {
+        let wallet_ffi_handle = load_existing_ffi_wallet(home.path());
+
+        let mut private_account = FfiAccount::default();
+
+        let result = wallet_ffi_get_account_private(
+            wallet_ffi_handle,
+            (&out_private_account_id) as *const FfiBytes32,
+            (&mut private_account) as *mut FfiAccount,
+        );
+        assert_eq!(result, error::WalletFfiError::Success);
+
+        let mut out_keys = FfiPrivateAccountKeys::default();
+        let result = wallet_ffi_get_private_account_keys(
+            wallet_ffi_handle,
+            (&out_private_account_id) as *const FfiBytes32,
+            (&mut out_keys) as *mut FfiPrivateAccountKeys,
+        );
+        assert_eq!(result, error::WalletFfiError::Success);
+
+        wallet_ffi_destroy(wallet_ffi_handle);
+
+        out_keys
+    };
+
+    assert_eq!(
+        nssa::AccountId::from(&private_account_keys.npk()),
+        out_private_account_id.into()
+    );
+
+    Ok(())
+}
 
 #[test]
 fn test_wallet_ffi_list_accounts() {
@@ -326,7 +438,8 @@ fn test_wallet_ffi_list_accounts() {
 fn test_wallet_ffi_get_balance_public() -> Result<()> {
     let ctx = BlockingTestContext::new()?;
     let account_id: AccountId = ctx.ctx().existing_public_accounts()[0];
-    let wallet_ffi_handle = new_wallet_ffi_with_test_context_config(&ctx);
+    let home = tempfile::tempdir().unwrap();
+    let wallet_ffi_handle = new_wallet_ffi_with_test_context_config(&ctx, home.path());
 
     let balance = unsafe {
         let mut out_balance: [u8; 16] = [0; 16];
@@ -354,7 +467,8 @@ fn test_wallet_ffi_get_balance_public() -> Result<()> {
 fn test_wallet_ffi_get_account_public() -> Result<()> {
     let ctx = BlockingTestContext::new()?;
     let account_id: AccountId = ctx.ctx().existing_public_accounts()[0];
-    let wallet_ffi_handle = new_wallet_ffi_with_test_context_config(&ctx);
+    let home = tempfile::tempdir().unwrap();
+    let wallet_ffi_handle = new_wallet_ffi_with_test_context_config(&ctx, home.path());
     let mut out_account = FfiAccount::default();
 
     let account: Account = unsafe {
@@ -385,11 +499,48 @@ fn test_wallet_ffi_get_account_public() -> Result<()> {
     Ok(())
 }
 
+#[test]
+fn test_wallet_ffi_get_account_private() -> Result<()> {
+    let ctx = BlockingTestContext::new()?;
+    let account_id: AccountId = ctx.ctx().existing_private_accounts()[0];
+    let home = tempfile::tempdir().unwrap();
+    let wallet_ffi_handle = new_wallet_ffi_with_test_context_config(&ctx, home.path());
+    let mut out_account = FfiAccount::default();
+
+    let account: Account = unsafe {
+        let ffi_account_id = FfiBytes32::from(&account_id);
+        let _result = wallet_ffi_get_account_private(
+            wallet_ffi_handle,
+            (&ffi_account_id) as *const FfiBytes32,
+            (&mut out_account) as *mut FfiAccount,
+        );
+        (&out_account).try_into().unwrap()
+    };
+
+    assert_eq!(
+        account.program_owner,
+        Program::authenticated_transfer_program().id()
+    );
+    assert_eq!(account.balance, 10000);
+    assert!(account.data.is_empty());
+    assert_eq!(account.nonce, 0);
+
+    unsafe {
+        wallet_ffi_free_account_data((&mut out_account) as *mut FfiAccount);
+        wallet_ffi_destroy(wallet_ffi_handle);
+    }
+
+    info!("Successfully retrieved account with correct details");
+
+    Ok(())
+}
+
 #[test]
 fn test_wallet_ffi_get_public_account_keys() -> Result<()> {
     let ctx = BlockingTestContext::new()?;
     let account_id: AccountId = ctx.ctx().existing_public_accounts()[0];
-    let wallet_ffi_handle = new_wallet_ffi_with_test_context_config(&ctx);
+    let home = tempfile::tempdir().unwrap();
+    let wallet_ffi_handle = new_wallet_ffi_with_test_context_config(&ctx, home.path());
     let mut out_key = FfiPublicAccountKey::default();
 
     let key: PublicKey = unsafe {
@@ -426,7 +577,8 @@ fn test_wallet_ffi_get_public_account_keys() -> Result<()> {
 fn test_wallet_ffi_get_private_account_keys() -> Result<()> {
     let ctx = BlockingTestContext::new()?;
     let account_id: AccountId = ctx.ctx().existing_private_accounts()[0];
-    let wallet_ffi_handle = new_wallet_ffi_with_test_context_config(&ctx);
+    let home = tempfile::tempdir().unwrap();
+    let wallet_ffi_handle = new_wallet_ffi_with_test_context_config(&ctx, home.path());
     let mut keys = FfiPrivateAccountKeys::default();
 
     unsafe {
@@ -448,10 +600,10 @@ fn test_wallet_ffi_get_private_account_keys() -> Result<()> {
         .0;
 
     let expected_npk = &key_chain.nullifer_public_key;
-    let expected_ivk = &key_chain.incoming_viewing_public_key;
+    let expected_vpk = &key_chain.viewing_public_key;
 
     assert_eq!(&keys.npk(), expected_npk);
-    assert_eq!(&keys.ivk().unwrap(), expected_ivk);
+    assert_eq!(&keys.vpk().unwrap(), expected_vpk);
 
     unsafe {
         wallet_ffi_free_private_account_keys((&mut keys) as *mut FfiPrivateAccountKeys);
@@ -504,7 +656,8 @@ fn test_wallet_ffi_base58_to_account_id() {
 #[test]
 fn test_wallet_ffi_init_public_account_auth_transfer() -> Result<()> {
     let ctx = BlockingTestContext::new().unwrap();
-    let wallet_ffi_handle = new_wallet_ffi_with_test_context_config(&ctx);
+    let home = tempfile::tempdir().unwrap();
+    let wallet_ffi_handle = new_wallet_ffi_with_test_context_config(&ctx, home.path());
 
     // Create a new uninitialized public account
     let mut out_account_id = FfiBytes32::from_bytes([0; 32]);
@@ -563,10 +716,81 @@ fn test_wallet_ffi_init_public_account_auth_transfer() -> Result<()> {
     Ok(())
 }
 
+#[test]
+fn test_wallet_ffi_init_private_account_auth_transfer() -> Result<()> {
+    let ctx = BlockingTestContext::new().unwrap();
+    let home = tempfile::tempdir().unwrap();
+    let wallet_ffi_handle = new_wallet_ffi_with_test_context_config(&ctx, home.path());
+
+    // Create a new uninitialized public account
+    let mut out_account_id = FfiBytes32::from_bytes([0; 32]);
+    unsafe {
+        wallet_ffi_create_account_private(
+            wallet_ffi_handle,
+            (&mut out_account_id) as *mut FfiBytes32,
+        );
+    }
+
+    // Check its program owner is the default program id
+    let account: Account = unsafe {
+        let mut out_account = FfiAccount::default();
+        wallet_ffi_get_account_private(
+            wallet_ffi_handle,
+            (&out_account_id) as *const FfiBytes32,
+            (&mut out_account) as *mut FfiAccount,
+        );
+        (&out_account).try_into().unwrap()
+    };
+    assert_eq!(account.program_owner, DEFAULT_PROGRAM_ID);
+
+    // Call the init funciton
+    let mut transfer_result = FfiTransferResult::default();
+    unsafe {
+        wallet_ffi_register_private_account(
+            wallet_ffi_handle,
+            (&out_account_id) as *const FfiBytes32,
+            (&mut transfer_result) as *mut FfiTransferResult,
+        );
+    }
+
+    info!("Waiting for next block creation");
+    std::thread::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS));
+
+    // Sync private account local storage with onchain encrypted state
+    unsafe {
+        let mut current_height = 0;
+        wallet_ffi_get_current_block_height(wallet_ffi_handle, (&mut current_height) as *mut u64);
+        wallet_ffi_sync_to_block(wallet_ffi_handle, current_height);
+    };
+
+    // Check that the program owner is now the authenticated transfer program
+    let account: Account = unsafe {
+        let mut out_account = FfiAccount::default();
+        let _result = wallet_ffi_get_account_private(
+            wallet_ffi_handle,
+            (&out_account_id) as *const FfiBytes32,
+            (&mut out_account) as *mut FfiAccount,
+        );
+        (&out_account).try_into().unwrap()
+    };
+    assert_eq!(
+        account.program_owner,
+        Program::authenticated_transfer_program().id()
+    );
+
+    unsafe {
+        wallet_ffi_free_transfer_result((&mut transfer_result) as *mut FfiTransferResult);
+        wallet_ffi_destroy(wallet_ffi_handle);
+    }
+
+    Ok(())
+}
+
 #[test]
 fn test_wallet_ffi_transfer_public() -> Result<()> {
     let ctx = BlockingTestContext::new().unwrap();
-    let wallet_ffi_handle = new_wallet_ffi_with_test_context_config(&ctx);
+    let home = tempfile::tempdir().unwrap();
+    let wallet_ffi_handle = new_wallet_ffi_with_test_context_config(&ctx, home.path());
     let from: FfiBytes32 = (&ctx.ctx().existing_public_accounts()[0]).into();
     let to: FfiBytes32 = (&ctx.ctx().existing_public_accounts()[1]).into();
     let amount: [u8; 16] = 100u128.to_le_bytes();
@@ -617,3 +841,220 @@ fn test_wallet_ffi_transfer_public() -> Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn test_wallet_ffi_transfer_shielded() -> Result<()> {
+    let ctx = BlockingTestContext::new().unwrap();
+    let home = tempfile::tempdir().unwrap();
+    let wallet_ffi_handle = new_wallet_ffi_with_test_context_config(&ctx, home.path());
+    let from: FfiBytes32 = (&ctx.ctx().existing_public_accounts()[0]).into();
+    let (to, to_keys) = unsafe {
+        let mut out_account_id = FfiBytes32::default();
+        let mut out_keys = FfiPrivateAccountKeys::default();
+        wallet_ffi_create_account_private(
+            wallet_ffi_handle,
+            (&mut out_account_id) as *mut FfiBytes32,
+        );
+        wallet_ffi_get_private_account_keys(
+            wallet_ffi_handle,
+            (&out_account_id) as *const FfiBytes32,
+            (&mut out_keys) as *mut FfiPrivateAccountKeys,
+        );
+        (out_account_id, out_keys)
+    };
+    let amount: [u8; 16] = 100u128.to_le_bytes();
+
+    let mut transfer_result = FfiTransferResult::default();
+    unsafe {
+        wallet_ffi_transfer_shielded(
+            wallet_ffi_handle,
+            (&from) as *const FfiBytes32,
+            (&to_keys) as *const FfiPrivateAccountKeys,
+            (&amount) as *const [u8; 16],
+            (&mut transfer_result) as *mut FfiTransferResult,
+        );
+    }
+
+    info!("Waiting for next block creation");
+    std::thread::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS));
+
+    // Sync private account local storage with onchain encrypted state
+    unsafe {
+        let mut current_height = 0;
+        wallet_ffi_get_current_block_height(wallet_ffi_handle, (&mut current_height) as *mut u64);
+        wallet_ffi_sync_to_block(wallet_ffi_handle, current_height);
+    };
+
+    let from_balance = unsafe {
+        let mut out_balance: [u8; 16] = [0; 16];
+        let _result = wallet_ffi_get_balance(
+            wallet_ffi_handle,
+            (&from) as *const FfiBytes32,
+            true,
+            (&mut out_balance) as *mut [u8; 16],
+        );
+        u128::from_le_bytes(out_balance)
+    };
+
+    let to_balance = unsafe {
+        let mut out_balance: [u8; 16] = [0; 16];
+        let _result = wallet_ffi_get_balance(
+            wallet_ffi_handle,
+            (&to) as *const FfiBytes32,
+            false,
+            (&mut out_balance) as *mut [u8; 16],
+        );
+        u128::from_le_bytes(out_balance)
+    };
+
+    assert_eq!(from_balance, 9900);
+    assert_eq!(to_balance, 100);
+
+    unsafe {
+        wallet_ffi_free_transfer_result((&mut transfer_result) as *mut FfiTransferResult);
+        wallet_ffi_destroy(wallet_ffi_handle);
+    }
+
+    Ok(())
+}
+
+#[test]
+fn test_wallet_ffi_transfer_deshielded() -> Result<()> {
+    let ctx = BlockingTestContext::new().unwrap();
+    let home = tempfile::tempdir().unwrap();
+    let wallet_ffi_handle = new_wallet_ffi_with_test_context_config(&ctx, home.path());
+    let from: FfiBytes32 = (&ctx.ctx().existing_private_accounts()[0]).into();
+    let to = FfiBytes32::from_bytes([37; 32]);
+    let amount: [u8; 16] = 100u128.to_le_bytes();
+
+    let mut transfer_result = FfiTransferResult::default();
+    unsafe {
+        wallet_ffi_transfer_deshielded(
+            wallet_ffi_handle,
+            (&from) as *const FfiBytes32,
+            (&to) as *const FfiBytes32,
+            (&amount) as *const [u8; 16],
+            (&mut transfer_result) as *mut FfiTransferResult,
+        );
+    }
+
+    info!("Waiting for next block creation");
+    std::thread::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS));
+
+    // Sync private account local storage with onchain encrypted state
+    unsafe {
+        let mut current_height = 0;
+        wallet_ffi_get_current_block_height(wallet_ffi_handle, (&mut current_height) as *mut u64);
+        wallet_ffi_sync_to_block(wallet_ffi_handle, current_height);
+    };
+
+    let from_balance = unsafe {
+        let mut out_balance: [u8; 16] = [0; 16];
+        let _result = wallet_ffi_get_balance(
+            wallet_ffi_handle,
+            (&from) as *const FfiBytes32,
+            false,
+            (&mut out_balance) as *mut [u8; 16],
+        );
+        u128::from_le_bytes(out_balance)
+    };
+
+    let to_balance = unsafe {
+        let mut out_balance: [u8; 16] = [0; 16];
+        let _result = wallet_ffi_get_balance(
+            wallet_ffi_handle,
+            (&to) as *const FfiBytes32,
+            true,
+            (&mut out_balance) as *mut [u8; 16],
+        );
+        u128::from_le_bytes(out_balance)
+    };
+
+    assert_eq!(from_balance, 9900);
+    assert_eq!(to_balance, 100);
+
+    unsafe {
+        wallet_ffi_free_transfer_result((&mut transfer_result) as *mut FfiTransferResult);
+        wallet_ffi_destroy(wallet_ffi_handle);
+    }
+
+    Ok(())
+}
+
+#[test]
+fn test_wallet_ffi_transfer_private() -> Result<()> {
+    let ctx = BlockingTestContext::new().unwrap();
+    let home = tempfile::tempdir().unwrap();
+    let wallet_ffi_handle = new_wallet_ffi_with_test_context_config(&ctx, home.path());
+
+    let from: FfiBytes32 = (&ctx.ctx().existing_private_accounts()[0]).into();
+    let (to, to_keys) = unsafe {
+        let mut out_account_id = FfiBytes32::default();
+        let mut out_keys = FfiPrivateAccountKeys::default();
+        wallet_ffi_create_account_private(
+            wallet_ffi_handle,
+            (&mut out_account_id) as *mut FfiBytes32,
+        );
+        wallet_ffi_get_private_account_keys(
+            wallet_ffi_handle,
+            (&out_account_id) as *const FfiBytes32,
+            (&mut out_keys) as *mut FfiPrivateAccountKeys,
+        );
+        (out_account_id, out_keys)
+    };
+
+    let amount: [u8; 16] = 100u128.to_le_bytes();
+
+    let mut transfer_result = FfiTransferResult::default();
+    unsafe {
+        wallet_ffi_transfer_private(
+            wallet_ffi_handle,
+            (&from) as *const FfiBytes32,
+            (&to_keys) as *const FfiPrivateAccountKeys,
+            (&amount) as *const [u8; 16],
+            (&mut transfer_result) as *mut FfiTransferResult,
+        );
+    }
+
+    info!("Waiting for next block creation");
+    std::thread::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS));
+
+    // Sync private account local storage with onchain encrypted state
+    unsafe {
+        let mut current_height = 0;
+        wallet_ffi_get_current_block_height(wallet_ffi_handle, (&mut current_height) as *mut u64);
+        wallet_ffi_sync_to_block(wallet_ffi_handle, current_height);
+    };
+
+    let from_balance = unsafe {
+        let mut out_balance: [u8; 16] = [0; 16];
+        let _result = wallet_ffi_get_balance(
+            wallet_ffi_handle,
+            (&from) as *const FfiBytes32,
+            false,
+            (&mut out_balance) as *mut [u8; 16],
+        );
+        u128::from_le_bytes(out_balance)
+    };
+
+    let to_balance = unsafe {
+        let mut out_balance: [u8; 16] = [0; 16];
+        let _result = wallet_ffi_get_balance(
+            wallet_ffi_handle,
+            (&to) as *const FfiBytes32,
+            false,
+            (&mut out_balance) as *mut [u8; 16],
+        );
+        u128::from_le_bytes(out_balance)
+    };
+
+    assert_eq!(from_balance, 9900);
+    assert_eq!(to_balance, 100);
+
+    unsafe {
+        wallet_ffi_free_transfer_result((&mut transfer_result) as *mut FfiTransferResult);
+        wallet_ffi_destroy(wallet_ffi_handle);
+    }
+
+    Ok(())
+}