Rename the coins folder to networks (#583)

* Rename the coins folder to networks

Ethereum isn't a coin. It's a network.

Resolves #357.

* More renames of coins -> networks in orchestration

* Correct paths in tests/

* cargo fmt

networks/monero/wallet/tests/decoys.rs

@@ -0,0 +1,165 @@
+use monero_simple_request_rpc::SimpleRequestRpc;
+use monero_wallet::{
+  DEFAULT_LOCK_WINDOW,
+  transaction::Transaction,
+  rpc::{Rpc, DecoyRpc},
+  WalletOutput,
+};
+
+mod runner;
+
+test!(
+  select_latest_output_as_decoy_canonical,
+  (
+    // First make an initial tx0
+    |_, mut builder: Builder, addr| async move {
+      builder.add_payment(addr, 2000000000000);
+      (builder.build().unwrap(), ())
+    },
+    |rpc, block, tx: Transaction, mut scanner: Scanner, ()| async move {
+      let output =
+        scanner.scan(&rpc, &block).await.unwrap().not_additionally_locked().swap_remove(0);
+      assert_eq!(output.transaction(), tx.hash());
+      assert_eq!(output.commitment().amount, 2000000000000);
+      output
+    },
+  ),
+  (
+    // Then make a second tx1
+    |rct_type: RctType, rpc: SimpleRequestRpc, mut builder: Builder, addr, state: _| async move {
+      let output_tx0: WalletOutput = state;
+
+      let input = OutputWithDecoys::fingerprintable_deterministic_new(
+        &mut OsRng,
+        &rpc,
+        ring_len(rct_type),
+        rpc.get_height().await.unwrap(),
+        output_tx0.clone(),
+      )
+      .await
+      .unwrap();
+      builder.add_input(input);
+      builder.add_payment(addr, 1000000000000);
+
+      (builder.build().unwrap(), (rct_type, output_tx0))
+    },
+    // Then make sure DSA selects freshly unlocked output from tx1 as a decoy
+    |rpc, _, tx: Transaction, _: Scanner, state: (_, _)| async move {
+      use rand_core::OsRng;
+
+      let rpc: SimpleRequestRpc = rpc;
+
+      let height = rpc.get_height().await.unwrap();
+
+      let most_recent_o_index = rpc.get_o_indexes(tx.hash()).await.unwrap().pop().unwrap();
+
+      // Make sure output from tx1 is in the block in which it unlocks
+      let out_tx1 = rpc.get_outs(&[most_recent_o_index]).await.unwrap().swap_remove(0);
+      assert_eq!(out_tx1.height, height - DEFAULT_LOCK_WINDOW);
+      assert!(out_tx1.unlocked);
+
+      // Select decoys using spendable output from tx0 as the real, and make sure DSA selects
+      // the freshly unlocked output from tx1 as a decoy
+      let (rct_type, output_tx0): (RctType, WalletOutput) = state;
+      let mut selected_fresh_decoy = false;
+      let mut attempts = 1000;
+      while !selected_fresh_decoy && attempts > 0 {
+        let decoys = OutputWithDecoys::fingerprintable_deterministic_new(
+          &mut OsRng, // TODO: use a seeded RNG to consistently select the latest output
+          &rpc,
+          ring_len(rct_type),
+          height,
+          output_tx0.clone(),
+        )
+        .await
+        .unwrap()
+        .decoys()
+        .clone();
+
+        selected_fresh_decoy = decoys.positions().contains(&most_recent_o_index);
+        attempts -= 1;
+      }
+
+      assert!(selected_fresh_decoy);
+      assert_eq!(height, rpc.get_height().await.unwrap());
+    },
+  ),
+);
+
+test!(
+  select_latest_output_as_decoy,
+  (
+    // First make an initial tx0
+    |_, mut builder: Builder, addr| async move {
+      builder.add_payment(addr, 2000000000000);
+      (builder.build().unwrap(), ())
+    },
+    |rpc: SimpleRequestRpc, block, tx: Transaction, mut scanner: Scanner, ()| async move {
+      let output =
+        scanner.scan(&rpc, &block).await.unwrap().not_additionally_locked().swap_remove(0);
+      assert_eq!(output.transaction(), tx.hash());
+      assert_eq!(output.commitment().amount, 2000000000000);
+      output
+    },
+  ),
+  (
+    // Then make a second tx1
+    |rct_type: RctType, rpc, mut builder: Builder, addr, output_tx0: WalletOutput| async move {
+      let rpc: SimpleRequestRpc = rpc;
+
+      let input = OutputWithDecoys::new(
+        &mut OsRng,
+        &rpc,
+        ring_len(rct_type),
+        rpc.get_height().await.unwrap(),
+        output_tx0.clone(),
+      )
+      .await
+      .unwrap();
+      builder.add_input(input);
+      builder.add_payment(addr, 1000000000000);
+
+      (builder.build().unwrap(), (rct_type, output_tx0))
+    },
+    // Then make sure DSA selects freshly unlocked output from tx1 as a decoy
+    |rpc, _, tx: Transaction, _: Scanner, state: (_, _)| async move {
+      use rand_core::OsRng;
+
+      let rpc: SimpleRequestRpc = rpc;
+
+      let height = rpc.get_height().await.unwrap();
+
+      let most_recent_o_index = rpc.get_o_indexes(tx.hash()).await.unwrap().pop().unwrap();
+
+      // Make sure output from tx1 is in the block in which it unlocks
+      let out_tx1 = rpc.get_outs(&[most_recent_o_index]).await.unwrap().swap_remove(0);
+      assert_eq!(out_tx1.height, height - DEFAULT_LOCK_WINDOW);
+      assert!(out_tx1.unlocked);
+
+      // Select decoys using spendable output from tx0 as the real, and make sure DSA selects
+      // the freshly unlocked output from tx1 as a decoy
+      let (rct_type, output_tx0): (RctType, WalletOutput) = state;
+      let mut selected_fresh_decoy = false;
+      let mut attempts = 1000;
+      while !selected_fresh_decoy && attempts > 0 {
+        let decoys = OutputWithDecoys::new(
+          &mut OsRng, // TODO: use a seeded RNG to consistently select the latest output
+          &rpc,
+          ring_len(rct_type),
+          height,
+          output_tx0.clone(),
+        )
+        .await
+        .unwrap()
+        .decoys()
+        .clone();
+
+        selected_fresh_decoy = decoys.positions().contains(&most_recent_o_index);
+        attempts -= 1;
+      }
+
+      assert!(selected_fresh_decoy);
+      assert_eq!(height, rpc.get_height().await.unwrap());
+    },
+  ),
+);