Fix #237

coins/monero/tests/runner.rs

@@ -155,7 +155,7 @@ macro_rules! test {
         use monero_serai::{
           random_scalar,
           wallet::{
-            address::{Network, AddressSpec}, ViewPair, Scanner, SignableTransaction,
+            address::{Network, AddressSpec}, ViewPair, Scanner, Change, SignableTransaction,
             SignableTransactionBuilder,
           },
         };
@@ -196,7 +196,13 @@ macro_rules! test {
           let builder = SignableTransactionBuilder::new(
             rpc.get_protocol().await.unwrap(),
             rpc.get_fee().await.unwrap(),
-            Some(random_address().2),
+            Some(Change::new(
+              &ViewPair::new(
+                &random_scalar(&mut OsRng) * &ED25519_BASEPOINT_TABLE,
+                Zeroizing::new(random_scalar(&mut OsRng))
+              ),
+              false
+            )),
           );
 
           let sign = |tx: SignableTransaction| {

coins/monero/tests/send.rs

@@ -1,6 +1,7 @@
 use monero_serai::{
-  wallet::{ReceivedOutput, SpendableOutput},
+  wallet::{extra::Extra, address::SubaddressIndex, ReceivedOutput, SpendableOutput},
   transaction::Transaction,
+  rpc::Rpc,
 };
 
 mod runner;
@@ -49,3 +50,69 @@ test!(
     },
   ),
 );
+
+test!(
+  // Ideally, this would be single_R, yet it isn't feasible to apply allow(non_snake_case) here
+  single_r_subaddress_send,
+  (
+    // Consume this builder for an output we can use in the future
+    // This is needed because we can't get the input from the passed in builder
+    |_, mut builder: Builder, addr| async move {
+      builder.add_payment(addr, 1000000000000);
+      (builder.build().unwrap(), ())
+    },
+    |_, tx: Transaction, mut scanner: Scanner, _| async move {
+      let mut outputs = scanner.scan_transaction(&tx).not_locked();
+      outputs.sort_by(|x, y| x.commitment().amount.cmp(&y.commitment().amount));
+      assert_eq!(outputs[0].commitment().amount, 1000000000000);
+      outputs
+    },
+  ),
+  (
+    |rpc: Rpc, _, _, mut outputs: Vec<ReceivedOutput>| async move {
+      let change_view = ViewPair::new(
+        &random_scalar(&mut OsRng) * &ED25519_BASEPOINT_TABLE,
+        Zeroizing::new(random_scalar(&mut OsRng)),
+      );
+
+      let mut builder = SignableTransactionBuilder::new(
+        rpc.get_protocol().await.unwrap(),
+        rpc.get_fee().await.unwrap(),
+        Some(Change::new(&change_view, false)),
+      );
+      builder.add_input(SpendableOutput::from(&rpc, outputs.swap_remove(0)).await.unwrap());
+
+      // Send to a subaddress
+      let sub_view = ViewPair::new(
+        &random_scalar(&mut OsRng) * &ED25519_BASEPOINT_TABLE,
+        Zeroizing::new(random_scalar(&mut OsRng)),
+      );
+      builder.add_payment(
+        sub_view
+          .address(Network::Mainnet, AddressSpec::Subaddress(SubaddressIndex::new(0, 1).unwrap())),
+        1,
+      );
+      (builder.build().unwrap(), (change_view, sub_view))
+    },
+    |_, tx: Transaction, _, views: (ViewPair, ViewPair)| async move {
+      // Make sure the change can pick up its output
+      let mut change_scanner = Scanner::from_view(views.0, Some(HashSet::new()));
+      assert!(change_scanner.scan_transaction(&tx).not_locked().len() == 1);
+
+      // Make sure the subaddress can pick up its output
+      let mut sub_scanner = Scanner::from_view(views.1, Some(HashSet::new()));
+      sub_scanner.register_subaddress(SubaddressIndex::new(0, 1).unwrap());
+      let sub_outputs = sub_scanner.scan_transaction(&tx).not_locked();
+      assert!(sub_outputs.len() == 1);
+      assert_eq!(sub_outputs[0].commitment().amount, 1);
+
+      // Make sure only one R was included in TX extra
+      assert!(Extra::read::<&[u8]>(&mut tx.prefix.extra.as_ref())
+        .unwrap()
+        .keys()
+        .unwrap()
+        .1
+        .is_none());
+    },
+  ),
+);

coins/monero/tests/wallet2_compatibility.rs

@@ -21,7 +21,7 @@ use monero_serai::{
   transaction::Transaction,
   wallet::{
     address::{Network, AddressSpec, SubaddressIndex, MoneroAddress},
-    extra::MAX_TX_EXTRA_NONCE_SIZE,
+    extra::{MAX_TX_EXTRA_NONCE_SIZE, Extra},
     Scanner,
   },
   rpc::Rpc,
@@ -56,7 +56,7 @@ async fn initialize_rpcs() -> (WalletClient, Rpc, monero_rpc::monero::Address) {
   let wallet_rpc_addr = if address_resp.is_ok() {
     address_resp.unwrap().address
   } else {
-    wallet_rpc.create_wallet("test_wallet".to_string(), None, "English".to_string()).await.unwrap();
+    wallet_rpc.create_wallet("wallet".to_string(), None, "English".to_string()).await.unwrap();
     let addr = wallet_rpc.get_address(0, None).await.unwrap().address;
     daemon_rpc.generate_blocks(&addr.to_string(), 70).await.unwrap();
     addr
@@ -64,7 +64,7 @@ async fn initialize_rpcs() -> (WalletClient, Rpc, monero_rpc::monero::Address) {
   (wallet_rpc, daemon_rpc, wallet_rpc_addr)
 }
 
-async fn test_from_wallet_rpc_to_self(spec: AddressSpec) {
+async fn from_wallet_rpc_to_self(spec: AddressSpec) {
   // initialize rpc
   let (wallet_rpc, daemon_rpc, wallet_rpc_addr) = initialize_rpcs().await;
 
@@ -109,24 +109,23 @@ async fn test_from_wallet_rpc_to_self(spec: AddressSpec) {
 }
 
 async_sequential!(
-  async fn test_receipt_of_wallet_rpc_tx_standard() {
-    test_from_wallet_rpc_to_self(AddressSpec::Standard).await;
+  async fn receipt_of_wallet_rpc_tx_standard() {
+    from_wallet_rpc_to_self(AddressSpec::Standard).await;
   }
 
-  async fn test_receipt_of_wallet_rpc_tx_subaddress() {
-    test_from_wallet_rpc_to_self(AddressSpec::Subaddress(SubaddressIndex::new(0, 1).unwrap()))
-      .await;
+  async fn receipt_of_wallet_rpc_tx_subaddress() {
+    from_wallet_rpc_to_self(AddressSpec::Subaddress(SubaddressIndex::new(0, 1).unwrap())).await;
   }
 
-  async fn test_receipt_of_wallet_rpc_tx_integrated() {
+  async fn receipt_of_wallet_rpc_tx_integrated() {
     let mut payment_id = [0u8; 8];
     OsRng.fill_bytes(&mut payment_id);
-    test_from_wallet_rpc_to_self(AddressSpec::Integrated(payment_id)).await;
+    from_wallet_rpc_to_self(AddressSpec::Integrated(payment_id)).await;
   }
 );
 
 test!(
-  test_send_to_wallet_rpc_standard,
+  send_to_wallet_rpc_standard,
   (
     |_, mut builder: Builder, _| async move {
       // initialize rpc
@@ -151,7 +150,7 @@ test!(
 );
 
 test!(
-  test_send_to_wallet_rpc_subaddress,
+  send_to_wallet_rpc_subaddress,
   (
     |_, mut builder: Builder, _| async move {
       // initialize rpc
@@ -173,12 +172,20 @@ test!(
         data.0.get_transfer(Hash::from_slice(&tx.hash()), None).await.unwrap().unwrap();
       assert_eq!(transfer.amount.as_pico(), 1000000);
       assert_eq!(transfer.subaddr_index, Index { major: 0, minor: data.1 });
+
+      // Make sure only one R was included in TX extra
+      assert!(Extra::read::<&[u8]>(&mut tx.prefix.extra.as_ref())
+        .unwrap()
+        .keys()
+        .unwrap()
+        .1
+        .is_none());
     },
   ),
 );
 
 test!(
-  test_send_to_wallet_rpc_integrated,
+  send_to_wallet_rpc_integrated,
   (
     |_, mut builder: Builder, _| async move {
       // initialize rpc
@@ -205,7 +212,7 @@ test!(
 );
 
 test!(
-  test_send_to_wallet_rpc_with_arb_data,
+  send_to_wallet_rpc_with_arb_data,
   (
     |_, mut builder: Builder, _| async move {
       // initialize rpc