add integration test for monero_wallet_ng::verify_transfer

Author: binarybaron

Cargo.lock

@@ -40,6 +40,7 @@ bdk_wallet = "2.0.0"
 bitcoin = { version = "0.32", features = ["rand", "serde"] }
 
 # monero-oxide
+monero-daemon-rpc = { git = "https://github.com/kayabaNerve/monero-oxide.git", branch = "rpc-rewrite" }
 monero-oxide = { git = "https://github.com/kayabaNerve/monero-oxide.git", branch = "rpc-rewrite" }
 monero-oxide-wallet = { git = "https://github.com/kayabaNerve/monero-oxide.git", package = "monero-wallet", branch = "rpc-rewrite" }
 monero-simple-request-rpc = { git = "https://github.com/kayabaNerve/monero-oxide.git", branch = "rpc-rewrite" }

Cargo.toml

@@ -4,14 +4,22 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+# Crypto
+curve25519-dalek = { workspace = true }
+
+# Database
+sqlx = { version = "0.8", features = ["sqlite", "runtime-tokio-rustls", "macros", "chrono"] }
+
+# Error handling
 anyhow = { workspace = true }
+thiserror = "2.0.17"
+
 backoff = { workspace = true }
 chrono = { version = "0.4", features = ["serde"] }
 cxx = "1.0.137"
+hex = "0.4"
 monero = { workspace = true }
 serde = { workspace = true }
-sqlx = { version = "0.8", features = ["sqlite", "runtime-tokio-rustls", "macros", "chrono"] }
-thiserror = "2.0.17"
 tokio = { workspace = true, features = ["sync", "time", "rt"] }
 tracing = { workspace = true }
 typeshare = { workspace = true }

monero-sys/Cargo.toml

@@ -303,6 +303,22 @@ namespace Monero
         return std::make_unique<std::string>(tx_info.hash());
     }
 
+    /**
+     * Get the secret view key of the wallet.
+     */
+    inline std::unique_ptr<std::string> secretViewKey(const Wallet &wallet)
+    {
+        return std::make_unique<std::string>(wallet.secretViewKey());
+    }
+
+    /**
+     * Get the public spend key of the wallet.
+     */
+    inline std::unique_ptr<std::string> publicSpendKey(const Wallet &wallet)
+    {
+        return std::make_unique<std::string>(wallet.publicSpendKey());
+    }
+
     /**
      * Get the timestamp of a transaction from TransactionInfo.
      */

monero-sys/src/bridge.h

@@ -385,6 +385,12 @@ pub mod ffi {
             total: &mut u64,
             spent: &mut u64,
         ) -> Result<bool>;
+
+        /// Get the secret view key of the wallet.
+        fn secretViewKey(wallet: &Wallet) -> Result<UniquePtr<CxxString>>;
+
+        /// Get the public spend key of the wallet.
+        fn publicSpendKey(wallet: &Wallet) -> Result<UniquePtr<CxxString>>;
     }
 }
 

monero-sys/src/bridge.rs

@@ -18,6 +18,7 @@ pub use bridge::{TraceListener, WalletEventListener, WalletListenerBox};
 pub use database::{Database, RecentWallet};
 use throttle::Throttle;
 
+use std::io::Cursor;
 use std::panic::{catch_unwind, AssertUnwindSafe};
 use std::sync::{Arc, Mutex};
 use std::{
@@ -584,6 +585,59 @@ impl WalletHandle {
             .context("Couldn't complete wallet call")?
     }
 
+    /// Get the secret view key of the wallet.
+    pub async fn secret_view_key(&self) -> anyhow::Result<curve25519_dalek::scalar::Scalar> {
+        let secret_view_key = self
+            .call(move |wallet| wallet.secret_view_key())
+            .await
+            .context("Couldn't complete wallet call")?
+            .context("Couldn't get secret view key string from wallet2")?;
+
+        let secret_view_key_bytes = hex::decode(&secret_view_key)
+            .context("Failed to decode secret view key string from wallet2 from hex to bytes")?;
+
+        let secret_view_key: [u8; 32] =
+            secret_view_key_bytes.try_into().map_err(|v: Vec<u8>| {
+                anyhow!(
+                    "Secret view key has wrong length: expected 32 bytes, got {}",
+                    v.len()
+                )
+            })?;
+
+        let private_view_key =
+            curve25519_dalek::scalar::Scalar::from_canonical_bytes(secret_view_key)
+                .into_option()
+                .context("Failed to convert secret view key bytes to Scalar")?;
+
+        Ok(private_view_key)
+    }
+
+    /// Get the public spend key of the wallet.
+    pub async fn public_spend_key(
+        &self,
+    ) -> anyhow::Result<curve25519_dalek::edwards::CompressedEdwardsY> {
+        let public_spend_key = self
+            .call(move |wallet| wallet.public_spend_key())
+            .await
+            .context("Couldn't complete wallet call")?
+            .context("Couldn't get public spend key string from wallet2")?;
+
+        let public_spend_key_bytes = hex::decode(&public_spend_key)
+            .context("Failed to decode public spend key string from wallet2 from hex to bytes")?;
+
+        let public_spend_key: [u8; 32] =
+            public_spend_key_bytes.try_into().map_err(|v: Vec<u8>| {
+                anyhow!(
+                    "Public spend key has wrong length: expected 32 bytes, got {}",
+                    v.len()
+                )
+            })?;
+
+        Ok(curve25519_dalek::edwards::CompressedEdwardsY(
+            public_spend_key,
+        ))
+    }
+
     /// Get the creation height of the wallet.
     pub async fn creation_height(&self) -> anyhow::Result<u64> {
         self.call(move |wallet| wallet.creation_height())
@@ -946,7 +1000,6 @@ impl WalletHandle {
         Ok(())
     }
 
-
     /// Wait for an incoming transaction with at least the specified amount.
     ///
     /// This method polls the wallet's transaction history at the specified interval
@@ -985,7 +1038,7 @@ impl WalletHandle {
                         confirmations = tx.confirmations,
                         "Found incoming transaction that meets the amount lower bound"
                     );
-                    
+
                     return Ok(tx);
                 }
             }
@@ -2664,6 +2717,32 @@ impl FfiWallet {
         Ok(seed)
     }
 
+    /// Get the secret view key of the wallet.
+    fn secret_view_key(&self) -> anyhow::Result<String> {
+        let key = ffi::secretViewKey(&self.inner)
+            .context("Failed to get secret view key")?
+            .to_string();
+
+        if key.is_empty() {
+            bail!("Failed to get secret view key");
+        }
+
+        Ok(key)
+    }
+
+    /// Get the public spend key of the wallet.
+    fn public_spend_key(&self) -> anyhow::Result<String> {
+        let key = ffi::publicSpendKey(&self.inner)
+            .context("Failed to get public spend key")?
+            .to_string();
+
+        if key.is_empty() {
+            bail!("wallet2 returned an empty public spend key");
+        }
+
+        Ok(key)
+    }
+
     /// Sign a message with the wallet's private key.
     ///
     /// # Arguments

monero-sys/src/lib.rs

@@ -5,14 +5,21 @@ edition = "2024"
 
 [dependencies]
 monero = { workspace = true }
+monero-daemon-rpc = { workspace = true }
 monero-harness = { path = "../monero-harness" }
+monero-oxide-wallet = { workspace = true }
+monero-simple-request-rpc = { workspace = true }
 monero-sys = { path = "../monero-sys" }
+monero-wallet-ng = { path = "../monero-wallet-ng" }
 testcontainers = { workspace = true }
 
 anyhow = { workspace = true }
+hex = "0.4"
 tokio = { workspace = true, features = ["macros", "rt"] }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
+uuid = { workspace = true }
+zeroize = "1.5"
 
 [lints]
 workspace = true

monero-tests/Cargo.toml

@@ -12,7 +12,8 @@ async fn monero_transfers() -> anyhow::Result<()> {
 
     let cli = Cli::default();
     let wallets = vec!["alice", "bob", "candice"];
-    // Disbale background sync for these wallet -- this way we _have_ to use the transfer proof to discover the transactions.
+
+    // Disable background sync for these wallet -- this way we _have_ to use the transfer proof to discover the transactions.
     let (monero, _container, _wallet_conainers) =
         monero_harness::Monero::new_with_sync_specified(&cli, wallets, false).await?;
 

monero-tests/tests/transaction_keys.rs

@@ -0,0 +1,106 @@
+use monero_daemon_rpc::MoneroDaemon;
+use monero_harness::image::RPC_PORT;
+use monero_harness::Cli;
+use monero_simple_request_rpc::SimpleRequestTransport;
+use monero_sys::{TxReceipt, WalletHandle};
+use monero_wallet_ng::verify_transfer;
+use testcontainers::Container;
+use zeroize::Zeroizing;
+
+type TestSetup<'a> = (
+    WalletHandle,
+    TxReceipt,
+    u64,
+    MoneroDaemon<SimpleRequestTransport>,
+    Container<'a, monero_harness::image::Monerod>,
+    Vec<Container<'a, monero_harness::image::MoneroWalletRpc>>,
+);
+
+async fn setup(cli: &Cli) -> anyhow::Result<TestSetup<'_>> {
+    tracing_subscriber::fmt()
+        .with_env_filter(
+            "info,test=debug,monero_harness=debug,monero_rpc=debug,monero_sys=trace,verify_transfer=trace",
+        )
+        .try_init()
+        .ok();
+
+    let wallets = vec!["alice"];
+    let (monero, monerod_container, wallet_containers) =
+        monero_harness::Monero::new(cli, wallets).await?;
+
+    monero.init_and_start_miner().await?;
+
+    let miner_wallet = monero.wallet("miner")?;
+    let alice = monero.wallet("alice")?;
+
+    assert!(miner_wallet.balance().await? > 0);
+
+    let alice_address = alice.address().await?;
+
+    let transfer_amount: u64 = 1_000_000_000_000; // 1 XMR in piconero
+
+    let tx_receipt = miner_wallet
+        .transfer(&alice_address, transfer_amount)
+        .await?;
+
+    monero.generate_block().await?;
+
+    let alice_wallet = alice.wallet().clone();
+
+    let rpc_port = monerod_container.get_host_port_ipv4(RPC_PORT);
+    let rpc_url = format!("http://127.0.0.1:{}", rpc_port);
+    let daemon = SimpleRequestTransport::new(rpc_url)
+        .await
+        .expect("failed to create RPC client");
+
+    Ok((
+        alice_wallet,
+        tx_receipt,
+        transfer_amount,
+        daemon,
+        monerod_container,
+        wallet_containers,
+    ))
+}
+
+/// Tests that `monero_wallet_ng::verify_transfer` correctly verifies a transaction sent to a wallet.
+#[tokio::test]
+async fn verify_transfer_succeeds_for_valid_transfer() -> anyhow::Result<()> {
+    let cli = Cli::default();
+    let (alice_wallet, tx_receipt, transfer_amount, daemon, _c, _wc) = setup(&cli).await?;
+
+    let tx_id: [u8; 32] = hex::decode(&tx_receipt.txid)?
+        .try_into()
+        .map_err(|_| anyhow::anyhow!("Invalid tx_id length"))?;
+
+    let secret_view_scalar = alice_wallet
+        .secret_view_key()
+        .await
+        .expect("Failed to get secret view key");
+    
+    let public_spend_compressed = alice_wallet
+        .public_spend_key()
+        .await
+        .expect("Failed to get public spend key");
+
+    let private_view_key = Zeroizing::new(secret_view_scalar);
+    let public_spend_key = public_spend_compressed
+        .decompress()
+        .expect("Failed to decompress public spend key");
+
+    let transfer_verified = verify_transfer(
+        &daemon,
+        tx_id,
+        public_spend_key,
+        private_view_key,
+        transfer_amount,
+    )
+    .await?;
+
+    assert!(
+        transfer_verified,
+        "verify_transfer should confirm the transfer amount"
+    );
+
+    Ok(())
+}

monero-tests/tests/verify_transfer.rs

@@ -6,12 +6,11 @@ use monero_oxide_wallet::ed25519::{CompressedPoint, Scalar};
 use monero_simple_request_rpc::SimpleRequestTransport;
 use zeroize::Zeroizing;
 
-use monero_wallet3::verify_transfer;
+use monero_wallet_ng::verify_transfer;
 
-/// Default Monero node URL if none provided via CLI
 const DEFAULT_NODE_URL: &str = "http://xmr-node.cakewallet.com:18081";
 
-/// Transaction ID to verify (hex encoded)
+/// Transaction ID to verify
 /// https://xmrchain.net/tx/fdd9ce7194cd8e6d14ecf7c5f49e7882be7248cde26215bb0bd9e20de1791b8e
 const TX_ID_HEX: &str = "fdd9ce7194cd8e6d14ecf7c5f49e7882be7248cde26215bb0bd9e20de1791b8e";
 
@@ -23,8 +22,8 @@ const SECRET_VIEW_KEY_HEX: &str =
 const PUBLIC_SPEND_KEY_HEX: &str =
     "1031c07d9b5772d14797826587d23135f2495a2bf173a5ae802f90d8fd1625be";
 
-/// Expected amount: 0.001 XMR = 1_000_000_000 piconero
-const EXPECTED_AMOUNT: u64 = 1_000_000_000;
+/// Expected amount (0.001 XMR)
+const EXPECTED_AMOUNT: u64 = 1_00_000_000;
 
 fn hex_to_bytes<const N: usize>(hex: &str) -> [u8; N] {
     let mut bytes = [0u8; N];