Merge branch 'main' into Pravdyvy/wallet-ffi-extension

integration_tests/tests/auth_transfer/private.rs

@@ -7,8 +7,14 @@ use integration_tests::{
     public_mention, verify_commitment_is_in_state,
 };
 use log::info;
-use nssa::{AccountId, program::Program};
-use nssa_core::{NullifierPublicKey, encryption::shared_key_derivation::Secp256k1Point};
+use nssa::{
+    AccountId, SharedSecretKey, execute_and_prove,
+    privacy_preserving_transaction::circuit::ProgramWithDependencies, program::Program,
+};
+use nssa_core::{
+    InputAccountIdentity, NullifierPublicKey, account::AccountWithMetadata,
+    encryption::shared_key_derivation::Secp256k1Point,
+};
 use sequencer_service_rpc::RpcClient as _;
 use tokio::test;
 use wallet::{
@@ -626,13 +632,7 @@ async fn shielded_transfers_to_two_identifiers_same_npk() -> Result<()> {
 }
 
 #[test]
-async fn ppt_that_chain_calls_faucet_is_dropped() -> Result<()> {
-    use nssa::{
-        EphemeralPublicKey, SharedSecretKey, execute_and_prove,
-        privacy_preserving_transaction::{self, circuit::ProgramWithDependencies},
-    };
-    use nssa_core::{InputAccountIdentity, account::AccountWithMetadata};
-
+async fn ppt_cant_chain_call_faucet() -> Result<()> {
     let ctx = TestContext::new().await?;
 
     let binary = std::fs::read(
@@ -656,7 +656,6 @@ async fn ppt_that_chain_calls_faucet_is_dropped() -> Result<()> {
     let npk = NullifierPublicKey::from(&nsk);
     let vpk = Secp256k1Point::from_scalar([4; 32]);
     let ssk = SharedSecretKey::new([55; 32], &vpk);
-    let epk = EphemeralPublicKey::from_scalar([55; 32]);
     let attacker_vault_id = {
         let seed = vault_core::compute_vault_seed(attacker_id);
         AccountId::for_private_pda(&vault_program_id, &seed, &npk, 1337)
@@ -695,7 +694,7 @@ async fn ppt_that_chain_calls_faucet_is_dropped() -> Result<()> {
     let instruction =
         Program::serialize_instruction((faucet_program_id, vault_program_id, attacker_id, amount))?;
 
-    let (output, proof) = execute_and_prove(
+    let res = execute_and_prove(
         vec![faucet_pre, vault_pda_pre],
         instruction,
         vec![
@@ -708,47 +707,9 @@ async fn ppt_that_chain_calls_faucet_is_dropped() -> Result<()> {
             },
         ],
         &program_with_deps,
-    )?;
+    );
 
-    let message = privacy_preserving_transaction::Message::try_from_circuit_output(
-        vec![faucet_account_id],
-        vec![],
-        vec![(npk, vpk, epk)],
-        output,
-    )?;
-    let witness_set = privacy_preserving_transaction::WitnessSet::for_message(&message, proof, &[]);
-    let attack_ppt = NSSATransaction::PrivacyPreserving(nssa::PrivacyPreservingTransaction::new(
-        message,
-        witness_set,
-    ));
-
-    let faucet_balance_before = ctx
-        .sequencer_client()
-        .get_account_balance(faucet_account_id)
-        .await?;
-    let vault_balance_before = ctx
-        .sequencer_client()
-        .get_account_balance(attacker_vault_id)
-        .await?;
-
-    let tx_hash = ctx.sequencer_client().send_transaction(attack_ppt).await?;
-
-    info!("Waiting for next block creation");
-    tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await;
-
-    let faucet_balance_after = ctx
-        .sequencer_client()
-        .get_account_balance(faucet_account_id)
-        .await?;
-    let vault_balance_after = ctx
-        .sequencer_client()
-        .get_account_balance(attacker_vault_id)
-        .await?;
-    let tx_on_chain = ctx.sequencer_client().get_transaction(tx_hash).await?;
-
-    assert_eq!(faucet_balance_after, faucet_balance_before);
-    assert_eq!(vault_balance_after, vault_balance_before);
-    assert!(tx_on_chain.is_none());
+    assert!(res.is_err());
 
     Ok(())
 }

integration_tests/tests/auth_transfer/public.rs

@@ -420,7 +420,7 @@ async fn cannot_execute_faucet_program() -> Result<()> {
         Program::faucet().id(),
         vec![faucet_account_id, recipient_vault_id],
         vec![],
-        faucet_core::Instruction::Transfer {
+        faucet_core::Instruction::GenesisTransferVault {
             vault_program_id,
             recipient_id: recipient,
             amount,

integration_tests/tests/bridge.rs

@@ -0,0 +1,450 @@
+#![expect(
+    clippy::tests_outside_test_module,
+    clippy::arithmetic_side_effects,
+    reason = "We don't care about these in tests"
+)]
+
+use std::time::Duration;
+
+use anyhow::Context as _;
+use borsh::BorshSerialize;
+use common::transaction::NSSATransaction;
+use integration_tests::{TIME_TO_WAIT_FOR_BLOCK_SECONDS, TestContext};
+use log::info;
+use logos_blockchain_core::mantle::{Value, ledger::Inputs, ops::channel::deposit::DepositOp};
+use logos_blockchain_http_api_common::bodies::{
+    channel::ChannelDepositRequestBody,
+    wallet::{
+        balance::WalletBalanceResponseBody,
+        transfer_funds::{WalletTransferFundsRequestBody, WalletTransferFundsResponseBody},
+    },
+};
+use nssa::{
+    AccountId, execute_and_prove, privacy_preserving_transaction, program::Program,
+    public_transaction,
+};
+use nssa_core::{InputAccountIdentity, account::AccountWithMetadata};
+use sequencer_service_rpc::RpcClient as _;
+use tokio::test;
+
+const TIME_TO_FINALIZE_DEPOSIT_EVENT_ON_BEDROCK: Duration = Duration::from_mins(2);
+
+#[test]
+async fn public_bridge_deposit_invocation_is_dropped() -> anyhow::Result<()> {
+    let ctx = TestContext::new().await?;
+
+    let recipient_id = ctx.existing_public_accounts()[0];
+    let bridge_account_id = nssa::system_bridge_account_id();
+    let vault_program_id = Program::vault().id();
+    let recipient_vault_id = vault_core::compute_vault_account_id(vault_program_id, recipient_id);
+
+    let message = public_transaction::Message::try_new(
+        Program::bridge().id(),
+        vec![bridge_account_id, recipient_vault_id],
+        vec![],
+        bridge_core::Instruction::Deposit {
+            vault_program_id,
+            recipient_id,
+            amount: 1,
+        },
+    )
+    .context("Failed to build public bridge deposit transaction")?;
+
+    let attack_tx = NSSATransaction::Public(nssa::PublicTransaction::new(
+        message,
+        nssa::public_transaction::WitnessSet::from_raw_parts(vec![]),
+    ));
+
+    let bridge_balance_before = ctx
+        .sequencer_client()
+        .get_account_balance(bridge_account_id)
+        .await?;
+    let vault_balance_before = ctx
+        .sequencer_client()
+        .get_account_balance(recipient_vault_id)
+        .await?;
+
+    let tx_hash = ctx.sequencer_client().send_transaction(attack_tx).await?;
+
+    tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await;
+
+    let bridge_balance_after = ctx
+        .sequencer_client()
+        .get_account_balance(bridge_account_id)
+        .await?;
+    let vault_balance_after = ctx
+        .sequencer_client()
+        .get_account_balance(recipient_vault_id)
+        .await?;
+    let tx_on_chain = ctx.sequencer_client().get_transaction(tx_hash).await?;
+
+    assert_eq!(bridge_balance_after, bridge_balance_before);
+    assert_eq!(vault_balance_after, vault_balance_before);
+    assert!(
+        tx_on_chain.is_none(),
+        "Direct public bridge::Deposit invocation should be rejected"
+    );
+
+    Ok(())
+}
+
+#[test]
+async fn private_bridge_deposit_invocation_is_dropped() -> anyhow::Result<()> {
+    let ctx = TestContext::new().await?;
+
+    let recipient_id = ctx.existing_public_accounts()[0];
+    let bridge_account_id = nssa::system_bridge_account_id();
+    let vault_program_id = Program::vault().id();
+    let recipient_vault_id = vault_core::compute_vault_account_id(vault_program_id, recipient_id);
+
+    // Get pre-state of bridge and vault accounts
+    let bridge_pre = AccountWithMetadata::new(
+        ctx.sequencer_client()
+            .get_account(bridge_account_id)
+            .await?,
+        false,
+        bridge_account_id,
+    );
+    let vault_pre = AccountWithMetadata::new(
+        ctx.sequencer_client()
+            .get_account(recipient_vault_id)
+            .await?,
+        false,
+        recipient_vault_id,
+    );
+
+    // Create program with dependencies
+    let program_with_deps =
+        nssa::privacy_preserving_transaction::circuit::ProgramWithDependencies::new(
+            Program::bridge(),
+            [
+                (vault_program_id, Program::vault()),
+                (
+                    Program::authenticated_transfer_program().id(),
+                    Program::authenticated_transfer_program(),
+                ),
+            ]
+            .into(),
+        );
+
+    // Serialize the bridge deposit instruction
+    let instruction = Program::serialize_instruction(bridge_core::Instruction::Deposit {
+        vault_program_id,
+        recipient_id,
+        amount: 1,
+    })
+    .context("Failed to serialize bridge deposit instruction")?;
+
+    // Execute and prove the bridge deposit
+    let (output, proof) = execute_and_prove(
+        vec![bridge_pre.clone(), vault_pre.clone()],
+        instruction,
+        vec![InputAccountIdentity::Public, InputAccountIdentity::Public],
+        &program_with_deps,
+    )
+    .context("Failed to execute/prove bridge deposit")?;
+
+    // Create privacy-preserving transaction from circuit output
+    let message = privacy_preserving_transaction::Message::try_from_circuit_output(
+        vec![bridge_account_id, recipient_vault_id],
+        vec![bridge_pre.account.nonce, vault_pre.account.nonce],
+        vec![],
+        output,
+    )
+    .context("Failed to build privacy-preserving bridge deposit message")?;
+
+    let witness_set = privacy_preserving_transaction::WitnessSet::for_message(&message, proof, &[]);
+    let attack_tx = NSSATransaction::PrivacyPreserving(nssa::PrivacyPreservingTransaction::new(
+        message,
+        witness_set,
+    ));
+
+    let bridge_balance_before = ctx
+        .sequencer_client()
+        .get_account_balance(bridge_account_id)
+        .await?;
+    let vault_balance_before = ctx
+        .sequencer_client()
+        .get_account_balance(recipient_vault_id)
+        .await?;
+
+    let tx_hash = ctx.sequencer_client().send_transaction(attack_tx).await?;
+
+    tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await;
+
+    let bridge_balance_after = ctx
+        .sequencer_client()
+        .get_account_balance(bridge_account_id)
+        .await?;
+    let vault_balance_after = ctx
+        .sequencer_client()
+        .get_account_balance(recipient_vault_id)
+        .await?;
+    let tx_on_chain = ctx.sequencer_client().get_transaction(tx_hash).await?;
+
+    assert_eq!(bridge_balance_after, bridge_balance_before);
+    assert_eq!(vault_balance_after, vault_balance_before);
+    assert!(
+        tx_on_chain.is_none(),
+        "Privacy-preserving bridge::Deposit invocation should be rejected"
+    );
+
+    Ok(())
+}
+
+async fn submit_bedrock_deposit(
+    bedrock_addr: std::net::SocketAddr,
+    recipient_id: AccountId,
+    amount: u128,
+) -> anyhow::Result<()> {
+    #[derive(BorshSerialize)]
+    struct DepositMetadata {
+        recipient_id: AccountId,
+    }
+
+    // Encode deposit metadata
+    let metadata = borsh::to_vec(&DepositMetadata { recipient_id })
+        .context("Failed to encode deposit metadata")?;
+
+    let funding_key = "2e03b2eff5a45478e7e79668d2a146cf2c5c7925bce927f2b1c67f2ab4fc0d26";
+
+    let amount: Value = amount
+        .try_into()
+        .context("Deposit amount does not fit Bedrock Value type")?;
+    let channel_id = integration_tests::config::bedrock_channel_id();
+    let client = reqwest::Client::new();
+
+    let query_balance = || async {
+        let balance_response = client
+            .get(format!(
+                "http://{bedrock_addr}/wallet/{funding_key}/balance"
+            ))
+            .send()
+            .await
+            .context("Failed to query Bedrock wallet balance")?;
+
+        let balance_response = check_response_success(balance_response).await?;
+
+        balance_response
+            .json::<WalletBalanceResponseBody>()
+            .await
+            .context("Failed to decode Bedrock balance response")
+    };
+
+    let mut balance = query_balance().await?;
+
+    info!(
+        "Queried Bedrock balance for key {funding_key}: {:?}",
+        balance.balance
+    );
+
+    if balance.balance < amount {
+        anyhow::bail!(
+            "Bedrock wallet with key {funding_key} has insufficient balance {:?} for deposit amount {:?}",
+            balance.balance,
+            amount
+        );
+    }
+
+    let mut selected_note_id = balance
+        .notes
+        .iter()
+        .find_map(|(note_id, value)| (*value == amount).then_some(*note_id));
+
+    if selected_note_id.is_none() {
+        let transfer_body = WalletTransferFundsRequestBody {
+            tip: None,
+            change_public_key: balance.address,
+            funding_public_keys: vec![balance.address],
+            recipient_public_key: balance.address,
+            amount,
+        };
+
+        let transfer_response = client
+            .post(format!(
+                "http://{bedrock_addr}/wallet/transactions/transfer-funds"
+            ))
+            .json(&transfer_body)
+            .send()
+            .await
+            .context("Failed to submit Bedrock transfer-funds request")?;
+        let transfer_response = check_response_success(transfer_response).await?;
+
+        let transfer: WalletTransferFundsResponseBody = transfer_response
+            .json()
+            .await
+            .context("Failed to decode Bedrock transfer-funds response")?;
+
+        info!(
+            "Submitted transfer-funds to create exact deposit note, tx hash {:?}",
+            transfer.hash
+        );
+
+        let mut found_note = None;
+        for _ in 0..20 {
+            tokio::time::sleep(Duration::from_millis(500)).await;
+            balance = query_balance().await?;
+            found_note = balance
+                .notes
+                .iter()
+                .find_map(|(note_id, value)| (*value == amount).then_some(*note_id));
+            if found_note.is_some() {
+                break;
+            }
+        }
+
+        selected_note_id = found_note;
+    }
+
+    let Some(selected_note_id) = selected_note_id else {
+        anyhow::bail!(
+            "Failed to locate exact-value note {amount:?} for Bedrock deposit; available notes: {:?}",
+            balance.notes,
+        );
+    };
+
+    let body = ChannelDepositRequestBody {
+        tip: None,
+        deposit: DepositOp {
+            channel_id,
+            inputs: Inputs::new(vec![selected_note_id]),
+            metadata,
+        },
+        change_public_key: balance.address,
+        funding_public_keys: vec![balance.address],
+        max_tx_fee: 1_000_u64.into(),
+    };
+
+    let response = client
+        .post(format!("http://{bedrock_addr}/channel/deposit"))
+        .json(&body)
+        .send()
+        .await
+        .context("Failed to submit Bedrock deposit request")?;
+    let response = check_response_success(response).await?;
+
+    let body_text = response
+        .text()
+        .await
+        .unwrap_or_else(|_| "<failed to decode>".to_owned());
+    info!(
+        "Successfully submitted Bedrock deposit request for recipient {recipient_id} and amount {amount}, response body: {body_text}",
+    );
+
+    Ok(())
+}
+
+async fn check_response_success(response: reqwest::Response) -> anyhow::Result<reqwest::Response> {
+    if response.status().is_success() {
+        Ok(response)
+    } else {
+        let status = response.status();
+        let body_text = response.text().await.unwrap_or_default();
+        anyhow::bail!("Request failed with status {status} and body {body_text}");
+    }
+}
+
+async fn wait_for_vault_balance(
+    ctx: &TestContext,
+    vault_id: AccountId,
+    expected_balance: u128,
+) -> anyhow::Result<()> {
+    let timeout = TIME_TO_FINALIZE_DEPOSIT_EVENT_ON_BEDROCK
+        + Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS);
+    tokio::time::timeout(timeout, async {
+        loop {
+            let balance = ctx.sequencer_client().get_account_balance(vault_id).await?;
+            if balance == expected_balance {
+                return Ok(());
+            }
+            tokio::time::sleep(Duration::from_millis(500)).await;
+        }
+    })
+    .await
+    .with_context(|| {
+        format!("Timed out waiting for vault {vault_id} balance to reach {expected_balance}")
+    })?
+}
+
+#[test]
+async fn bedrock_deposit_mints_to_vault_then_claim_succeeds() -> anyhow::Result<()> {
+    let ctx = TestContext::new().await?;
+
+    let recipient_id = ctx.existing_public_accounts()[0];
+    let vault_program_id = Program::vault().id();
+    let recipient_vault_id = vault_core::compute_vault_account_id(vault_program_id, recipient_id);
+
+    let vault_balance_before = ctx
+        .sequencer_client()
+        .get_account_balance(recipient_vault_id)
+        .await?;
+    let recipient_balance_before = ctx
+        .sequencer_client()
+        .get_account_balance(recipient_id)
+        .await?;
+
+    // Submit deposit to Bedrock
+    submit_bedrock_deposit(ctx.bedrock_addr(), recipient_id, 1).await?;
+
+    // Wait for vault to receive the deposit (minted from bridge to vault)
+    wait_for_vault_balance(&ctx, recipient_vault_id, vault_balance_before + 1).await?;
+
+    // Now claim funds from vault back to recipient
+    let nonces = ctx
+        .wallet()
+        .get_accounts_nonces(vec![recipient_id])
+        .await
+        .context("Failed to get nonce for vault claim")?;
+
+    let signing_key = ctx
+        .wallet()
+        .storage()
+        .key_chain()
+        .pub_account_signing_key(recipient_id)
+        .with_context(|| format!("Missing signing key for account {recipient_id}"))?;
+
+    let claim_message = public_transaction::Message::try_new(
+        vault_program_id,
+        vec![recipient_id, recipient_vault_id],
+        nonces,
+        vault_core::Instruction::Claim { amount: 1 },
+    )
+    .context("Failed to build vault claim message")?;
+
+    let claim_witness_set =
+        public_transaction::WitnessSet::for_message(&claim_message, &[signing_key]);
+    let claim_tx = NSSATransaction::Public(nssa::PublicTransaction::new(
+        claim_message,
+        claim_witness_set,
+    ));
+
+    let claim_hash = ctx.sequencer_client().send_transaction(claim_tx).await?;
+
+    tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await;
+
+    let claim_on_chain = ctx.sequencer_client().get_transaction(claim_hash).await?;
+    let vault_balance_after_claim = ctx
+        .sequencer_client()
+        .get_account_balance(recipient_vault_id)
+        .await?;
+    let recipient_balance_after_claim = ctx
+        .sequencer_client()
+        .get_account_balance(recipient_id)
+        .await?;
+
+    assert!(
+        claim_on_chain.is_some(),
+        "Vault claim transaction must be included on-chain"
+    );
+    assert_eq!(
+        vault_balance_after_claim, vault_balance_before,
+        "Vault balance should return to initial state after claim"
+    );
+    assert_eq!(
+        recipient_balance_after_claim,
+        recipient_balance_before + 1,
+        "Recipient balance should increase by claimed amount"
+    );
+
+    Ok(())
+}

integration_tests/tests/indexer.rs

@@ -20,13 +20,12 @@ use wallet::{
 };
 
 /// Maximum time to wait for the indexer to catch up to the sequencer.
-const L2_TO_L1_TIMEOUT_MILLIS: u64 = 180_000;
+const L2_TO_L1_TIMEOUT: Duration = Duration::from_mins(6);
 
 /// Poll the indexer until its last finalized block id reaches the sequencer's
 /// current last block id or until [`L2_TO_L1_TIMEOUT_MILLIS`] elapses.
 /// Returns the last indexer block id observed.
 async fn wait_for_indexer_to_catch_up(ctx: &TestContext) -> Result<u64> {
-    let timeout = Duration::from_millis(L2_TO_L1_TIMEOUT_MILLIS);
     let block_id_to_catch_up =
         sequencer_service_rpc::RpcClient::get_last_block_id(ctx.sequencer_client()).await?;
     let mut last_ind: u64 = 1;
@@ -50,11 +49,11 @@ async fn wait_for_indexer_to_catch_up(ctx: &TestContext) -> Result<u64> {
             tokio::time::sleep(Duration::from_secs(2)).await;
         }
     };
-    tokio::time::timeout(timeout, inner)
+    tokio::time::timeout(L2_TO_L1_TIMEOUT, inner)
         .await
         .with_context(|| {
             format!(
-                "Indexer failed to catch up within {L2_TO_L1_TIMEOUT_MILLIS} milliseconds. Last indexer block id observed: {last_ind}, but needed to catch up to at least {block_id_to_catch_up}"
+                "Indexer failed to catch up within {L2_TO_L1_TIMEOUT:?}. Last indexer block id observed: {last_ind}, but needed to catch up to at least {block_id_to_catch_up}"
             )
         })?
 }

integration_tests/tests/indexer_ffi.rs

@@ -10,6 +10,7 @@ use std::{
     fs::File,
     io::Write as _,
     net::SocketAddr,
+    time::Duration,
 };
 
 use anyhow::{Context as _, Result};
@@ -34,7 +35,7 @@ use wallet::{
 };
 
 /// Maximum time to wait for the indexer to catch up to the sequencer.
-const L2_TO_L1_TIMEOUT_MILLIS: u64 = 180_000;
+const L2_TO_L1_TIMEOUT: Duration = Duration::from_mins(6);
 
 unsafe extern "C" {
     unsafe fn query_last_block(
@@ -114,7 +115,7 @@ fn indexer_test_run_ffi() -> Result<()> {
     let (ctx, indexer_ffi, _indexer_dir) = setup()?;
 
     // RUN OBSERVATION
-    std::thread::sleep(std::time::Duration::from_millis(L2_TO_L1_TIMEOUT_MILLIS));
+    std::thread::sleep(L2_TO_L1_TIMEOUT);
 
     // Safety: ctx runtime is valid for the lifetime of the returned Runtime
     let runtime = unsafe { Runtime::from_borrowed(ctx.runtime()) };
@@ -138,7 +139,7 @@ fn indexer_ffi_block_batching() -> Result<()> {
 
     // WAIT
     info!("Waiting for indexer to parse blocks");
-    std::thread::sleep(std::time::Duration::from_millis(L2_TO_L1_TIMEOUT_MILLIS));
+    std::thread::sleep(L2_TO_L1_TIMEOUT);
 
     // Safety: ctx runtime is valid for the lifetime of the returned Runtime
     let runtime = unsafe { Runtime::from_borrowed(ctx.runtime()) };
@@ -265,7 +266,7 @@ fn indexer_ffi_state_consistency() -> Result<()> {
 
     // WAIT
     info!("Waiting for indexer to parse blocks");
-    std::thread::sleep(std::time::Duration::from_millis(L2_TO_L1_TIMEOUT_MILLIS));
+    std::thread::sleep(L2_TO_L1_TIMEOUT);
 
     // Safety: ctx runtime is valid for the lifetime of the returned Runtime
     let runtime = unsafe { Runtime::from_borrowed(ctx.runtime()) };
@@ -371,7 +372,7 @@ fn indexer_ffi_state_consistency_with_labels() -> Result<()> {
     assert_eq!(acc_2_balance, 20100);
 
     info!("Waiting for indexer to parse blocks");
-    std::thread::sleep(std::time::Duration::from_millis(L2_TO_L1_TIMEOUT_MILLIS));
+    std::thread::sleep(L2_TO_L1_TIMEOUT);
 
     // Safety: ctx runtime is valid for the lifetime of the returned Runtime
     let runtime = unsafe { Runtime::from_borrowed(ctx.runtime()) };