Merge branch 'main' into marvin/nonce

integration_tests/tests/indexer.rs

@@ -61,8 +61,11 @@ async fn indexer_block_batching() -> Result<()> {
 
     assert!(last_block_indexer > 1);
 
-    // Getting wide batch to fit all blocks
-    let block_batch = ctx.indexer_client().get_blocks(1, 100).await.unwrap();
+    // Getting wide batch to fit all blocks (from latest backwards)
+    let mut block_batch = ctx.indexer_client().get_blocks(None, 100).await.unwrap();
+
+    // Reverse to check chain consistency from oldest to newest
+    block_batch.reverse();
 
     // Checking chain consistency
     let mut prev_block_hash = block_batch.first().unwrap().header.hash;

integration_tests/tests/keys_restoration.rs

@@ -1,9 +1,9 @@
 use std::{str::FromStr, time::Duration};
 
-use anyhow::Result;
+use anyhow::{Context, Result};
 use integration_tests::{
-    TIME_TO_WAIT_FOR_BLOCK_SECONDS, TestContext, format_private_account_id,
-    format_public_account_id, verify_commitment_is_in_state,
+    TIME_TO_WAIT_FOR_BLOCK_SECONDS, TestContext, fetch_privacy_preserving_tx,
+    format_private_account_id, format_public_account_id, verify_commitment_is_in_state,
 };
 use key_protocol::key_management::key_tree::chain_index::ChainIndex;
 use log::info;
@@ -15,6 +15,93 @@ use wallet::cli::{
     programs::native_token_transfer::AuthTransferSubcommand,
 };
 
+#[test]
+async fn sync_private_account_with_non_zero_chain_index() -> Result<()> {
+    let mut ctx = TestContext::new().await?;
+
+    let from: AccountId = ctx.existing_private_accounts()[0];
+
+    // Create a new private account
+    let command = Command::Account(AccountSubcommand::New(NewSubcommand::Private {
+        cci: None,
+        label: None,
+    }));
+
+    for _ in 0..3 {
+        // Key Tree shift
+        // This way we have account with child index > 0.
+        let result = wallet::cli::execute_subcommand(
+            ctx.wallet_mut(),
+            Command::Account(AccountSubcommand::New(NewSubcommand::Private {
+                cci: None,
+                label: None,
+            })),
+        )
+        .await?;
+        let SubcommandReturnValue::RegisterAccount { account_id: _ } = result else {
+            anyhow::bail!("Expected RegisterAccount return value");
+        };
+    }
+
+    let sub_ret = wallet::cli::execute_subcommand(ctx.wallet_mut(), command).await?;
+    let SubcommandReturnValue::RegisterAccount {
+        account_id: to_account_id,
+    } = sub_ret
+    else {
+        anyhow::bail!("Expected RegisterAccount return value");
+    };
+
+    // Get the keys for the newly created account
+    let (to_keys, _) = ctx
+        .wallet()
+        .storage()
+        .user_data
+        .get_private_account(to_account_id)
+        .cloned()
+        .context("Failed to get private account")?;
+
+    // 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_vpk: Some(hex::encode(to_keys.viewing_public_key.0)),
+        amount: 100,
+    });
+
+    let sub_ret = wallet::cli::execute_subcommand(ctx.wallet_mut(), command).await?;
+    let SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash } = sub_ret else {
+        anyhow::bail!("Expected PrivacyPreservingTransfer return value");
+    };
+
+    let tx = fetch_privacy_preserving_tx(ctx.sequencer_client(), tx_hash).await;
+
+    // Sync the wallet to claim the new account
+    let command = Command::Account(AccountSubcommand::SyncPrivate {});
+    wallet::cli::execute_subcommand(ctx.wallet_mut(), command).await?;
+
+    let new_commitment1 = ctx
+        .wallet()
+        .get_private_account_commitment(from)
+        .context("Failed to get private account commitment for sender")?;
+    assert_eq!(tx.message.new_commitments[0], new_commitment1);
+
+    assert_eq!(tx.message.new_commitments.len(), 2);
+    for commitment in tx.message.new_commitments.into_iter() {
+        assert!(verify_commitment_is_in_state(commitment, ctx.sequencer_client()).await);
+    }
+
+    let to_res_acc = ctx
+        .wallet()
+        .get_account_private(to_account_id)
+        .context("Failed to get recipient's private account")?;
+    assert_eq!(to_res_acc.balance, 100);
+
+    info!("Successfully transferred using claiming path");
+
+    Ok(())
+}
+
 #[test]
 async fn restore_keys_from_seed() -> Result<()> {
     let mut ctx = TestContext::new().await?;

integration_tests/tests/pinata.rs

@@ -16,6 +16,118 @@ use wallet::cli::{
     },
 };
 
+#[test]
+async fn claim_pinata_to_uninitialized_public_account_fails_fast() -> Result<()> {
+    let mut ctx = TestContext::new().await?;
+
+    let result = wallet::cli::execute_subcommand(
+        ctx.wallet_mut(),
+        Command::Account(AccountSubcommand::New(NewSubcommand::Public {
+            cci: None,
+            label: None,
+        })),
+    )
+    .await?;
+    let SubcommandReturnValue::RegisterAccount {
+        account_id: winner_account_id,
+    } = result
+    else {
+        anyhow::bail!("Expected RegisterAccount return value");
+    };
+
+    let winner_account_id_formatted = format_public_account_id(winner_account_id);
+
+    let pinata_balance_pre = ctx
+        .sequencer_client()
+        .get_account_balance(PINATA_BASE58.parse().unwrap())
+        .await?
+        .balance;
+
+    let claim_result = wallet::cli::execute_subcommand(
+        ctx.wallet_mut(),
+        Command::Pinata(PinataProgramAgnosticSubcommand::Claim {
+            to: winner_account_id_formatted,
+        }),
+    )
+    .await;
+
+    assert!(
+        claim_result.is_err(),
+        "Expected uninitialized account error"
+    );
+    let err = claim_result.unwrap_err().to_string();
+    assert!(
+        err.contains("wallet auth-transfer init --account-id Public/"),
+        "Expected init guidance, got: {err}",
+    );
+
+    let pinata_balance_post = ctx
+        .sequencer_client()
+        .get_account_balance(PINATA_BASE58.parse().unwrap())
+        .await?
+        .balance;
+
+    assert_eq!(pinata_balance_post, pinata_balance_pre);
+
+    Ok(())
+}
+
+#[test]
+async fn claim_pinata_to_uninitialized_private_account_fails_fast() -> Result<()> {
+    let mut ctx = TestContext::new().await?;
+
+    let result = wallet::cli::execute_subcommand(
+        ctx.wallet_mut(),
+        Command::Account(AccountSubcommand::New(NewSubcommand::Private {
+            cci: None,
+            label: None,
+        })),
+    )
+    .await?;
+    let SubcommandReturnValue::RegisterAccount {
+        account_id: winner_account_id,
+    } = result
+    else {
+        anyhow::bail!("Expected RegisterAccount return value");
+    };
+
+    let winner_account_id_formatted = format_private_account_id(winner_account_id);
+
+    let pinata_balance_pre = ctx
+        .sequencer_client()
+        .get_account_balance(PINATA_BASE58.parse().unwrap())
+        .await?
+        .balance;
+
+    let claim_result = wallet::cli::execute_subcommand(
+        ctx.wallet_mut(),
+        Command::Pinata(PinataProgramAgnosticSubcommand::Claim {
+            to: winner_account_id_formatted,
+        }),
+    )
+    .await;
+
+    assert!(
+        claim_result.is_err(),
+        "Expected uninitialized account error"
+    );
+    let err = claim_result.unwrap_err().to_string();
+    assert!(
+        err.contains("wallet auth-transfer init --account-id Private/"),
+        "Expected init guidance, got: {err}",
+    );
+
+    let pinata_balance_post = ctx
+        .sequencer_client()
+        .get_account_balance(PINATA_BASE58.parse().unwrap())
+        .await?
+        .balance;
+
+    assert_eq!(pinata_balance_post, pinata_balance_pre);
+
+    Ok(())
+}
+
 #[test]
 async fn claim_pinata_to_existing_public_account() -> Result<()> {
     let mut ctx = TestContext::new().await?;