Add ScannableBlock abstraction in the RPC

Makes scanning synchronous and only error upon a malicious node/unplanned for
hard fork.

networks/monero/wallet/tests/add_data.rs

@@ -1,8 +1,12 @@
 use monero_serai::transaction::Transaction;
+use monero_simple_request_rpc::SimpleRequestRpc;
 use monero_wallet::{rpc::Rpc, extra::MAX_ARBITRARY_DATA_SIZE, send::SendError};
 
 mod runner;
 
+#[allow(clippy::upper_case_acronyms)]
+type SRR = SimpleRequestRpc;
+
 test!(
   add_single_data_less_than_max,
   (
@@ -15,9 +19,8 @@ test!(
       builder.add_payment(addr, 5);
       (builder.build().unwrap(), (arbitrary_data,))
     },
-    |rpc, block, tx: Transaction, mut scanner: Scanner, data: (Vec<u8>,)| async move {
-      let output =
-        scanner.scan(&rpc, &block).await.unwrap().not_additionally_locked().swap_remove(0);
+    |_rpc: SRR, block, tx: Transaction, mut scanner: Scanner, data: (Vec<u8>,)| async move {
+      let output = scanner.scan(block).unwrap().not_additionally_locked().swap_remove(0);
       assert_eq!(output.transaction(), tx.hash());
       assert_eq!(output.commitment().amount, 5);
       assert_eq!(output.arbitrary_data()[0], data.0);
@@ -42,9 +45,8 @@ test!(
       builder.add_payment(addr, 5);
       (builder.build().unwrap(), data)
     },
-    |rpc, block, tx: Transaction, mut scanner: Scanner, data: Vec<Vec<u8>>| async move {
-      let output =
-        scanner.scan(&rpc, &block).await.unwrap().not_additionally_locked().swap_remove(0);
+    |_rpc: SRR, block, tx: Transaction, mut scanner: Scanner, data: Vec<Vec<u8>>| async move {
+      let output = scanner.scan(block).unwrap().not_additionally_locked().swap_remove(0);
       assert_eq!(output.transaction(), tx.hash());
       assert_eq!(output.commitment().amount, 5);
       assert_eq!(output.arbitrary_data(), data);
@@ -70,9 +72,8 @@ test!(
       builder.add_payment(addr, 5);
       (builder.build().unwrap(), data)
     },
-    |rpc, block, tx: Transaction, mut scanner: Scanner, data: Vec<u8>| async move {
-      let output =
-        scanner.scan(&rpc, &block).await.unwrap().not_additionally_locked().swap_remove(0);
+    |_rpc: SRR, block, tx: Transaction, mut scanner: Scanner, data: Vec<u8>| async move {
+      let output = scanner.scan(block).unwrap().not_additionally_locked().swap_remove(0);
       assert_eq!(output.transaction(), tx.hash());
       assert_eq!(output.commitment().amount, 5);
       assert_eq!(output.arbitrary_data(), vec![data]);

networks/monero/wallet/tests/decoys.rs

@@ -16,9 +16,8 @@ test!(
       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);
+    |_rpc: SimpleRequestRpc, block, tx: Transaction, mut scanner: Scanner, ()| async move {
+      let output = scanner.scan(block).unwrap().not_additionally_locked().swap_remove(0);
       assert_eq!(output.transaction(), tx.hash());
       assert_eq!(output.commitment().amount, 2000000000000);
       output
@@ -94,9 +93,8 @@ test!(
       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);
+    |_rpc: SimpleRequestRpc, block, tx: Transaction, mut scanner: Scanner, ()| async move {
+      let output = scanner.scan(block).unwrap().not_additionally_locked().swap_remove(0);
       assert_eq!(output.transaction(), tx.hash());
       assert_eq!(output.commitment().amount, 2000000000000);
       output

networks/monero/wallet/tests/runner/mod.rs

@@ -105,7 +105,11 @@ pub async fn get_miner_tx_output(rpc: &SimpleRequestRpc, view: &ViewPair) -> Wal
   rpc.generate_blocks(&view.legacy_address(Network::Mainnet), 60).await.unwrap();
 
   let block = rpc.get_block_by_number(start).await.unwrap();
-  scanner.scan(rpc, &block).await.unwrap().ignore_additional_timelock().swap_remove(0)
+  scanner
+    .scan(rpc.get_scannable_block(block).await.unwrap())
+    .unwrap()
+    .ignore_additional_timelock()
+    .swap_remove(0)
 }
 
 /// Make sure the weight and fee match the expected calculation.
@@ -315,6 +319,7 @@ macro_rules! test {
             rpc.publish_transaction(&signed).await.unwrap();
             let block =
               mine_until_unlocked(&rpc, &random_address().2, signed.hash()).await;
+            let block = rpc.get_scannable_block(block).await.unwrap();
             let tx = rpc.get_transaction(signed.hash()).await.unwrap();
             check_weight_and_fee(&tx, fee_rate);
             let scanner = Scanner::new(view.clone());
@@ -336,6 +341,7 @@ macro_rules! test {
             rpc.publish_transaction(&signed).await.unwrap();
             let block =
               mine_until_unlocked(&rpc, &random_address().2, signed.hash()).await;
+            let block = rpc.get_scannable_block(block).await.unwrap();
             let tx = rpc.get_transaction(signed.hash()).await.unwrap();
             if stringify!($name) != "spend_one_input_to_two_outputs_no_change" {
               // Skip weight and fee check for the above test because when there is no change,

networks/monero/wallet/tests/scan.rs

@@ -1,8 +1,14 @@
-use monero_serai::transaction::Transaction;
-use monero_wallet::{rpc::Rpc, address::SubaddressIndex, extra::PaymentId, GuaranteedScanner};
+use monero_simple_request_rpc::SimpleRequestRpc;
+use monero_wallet::{
+  transaction::Transaction, rpc::Rpc, address::SubaddressIndex, extra::PaymentId, GuaranteedScanner,
+};
 
 mod runner;
 
+#[allow(clippy::upper_case_acronyms)]
+type SRR = SimpleRequestRpc;
+type Tx = Transaction;
+
 test!(
   scan_standard_address,
   (
@@ -12,8 +18,8 @@ test!(
       builder.add_payment(view.legacy_address(Network::Mainnet), 5);
       (builder.build().unwrap(), scanner)
     },
-    |rpc, block, tx: Transaction, _, mut state: Scanner| async move {
-      let output = state.scan(&rpc, &block).await.unwrap().not_additionally_locked().swap_remove(0);
+    |_rpc: SRR, block, tx: Transaction, _, mut state: Scanner| async move {
+      let output = state.scan(block).unwrap().not_additionally_locked().swap_remove(0);
       assert_eq!(output.transaction(), tx.hash());
       assert_eq!(output.commitment().amount, 5);
       let dummy_payment_id = PaymentId::Encrypted([0u8; 8]);
@@ -35,9 +41,8 @@ test!(
       builder.add_payment(view.subaddress(Network::Mainnet, subaddress), 5);
       (builder.build().unwrap(), (scanner, subaddress))
     },
-    |rpc, block, tx: Transaction, _, mut state: (Scanner, SubaddressIndex)| async move {
-      let output =
-        state.0.scan(&rpc, &block).await.unwrap().not_additionally_locked().swap_remove(0);
+    |_rpc: SRR, block, tx: Transaction, _, mut state: (Scanner, SubaddressIndex)| async move {
+      let output = state.0.scan(block).unwrap().not_additionally_locked().swap_remove(0);
       assert_eq!(output.transaction(), tx.hash());
       assert_eq!(output.commitment().amount, 5);
       assert_eq!(output.subaddress(), Some(state.1));
@@ -58,9 +63,8 @@ test!(
       builder.add_payment(view.legacy_integrated_address(Network::Mainnet, payment_id), 5);
       (builder.build().unwrap(), (scanner, payment_id))
     },
-    |rpc, block, tx: Transaction, _, mut state: (Scanner, [u8; 8])| async move {
-      let output =
-        state.0.scan(&rpc, &block).await.unwrap().not_additionally_locked().swap_remove(0);
+    |_rpc: SRR, block, tx: Transaction, _, mut state: (Scanner, [u8; 8])| async move {
+      let output = state.0.scan(block).unwrap().not_additionally_locked().swap_remove(0);
       assert_eq!(output.transaction(), tx.hash());
       assert_eq!(output.commitment().amount, 5);
       assert_eq!(output.payment_id(), Some(PaymentId::Encrypted(state.1)));
@@ -77,9 +81,8 @@ test!(
       builder.add_payment(view.address(Network::Mainnet, None, None), 5);
       (builder.build().unwrap(), scanner)
     },
-    |rpc, block, tx: Transaction, _, mut scanner: GuaranteedScanner| async move {
-      let output =
-        scanner.scan(&rpc, &block).await.unwrap().not_additionally_locked().swap_remove(0);
+    |_rpc: SRR, block, tx: Transaction, _, mut scanner: GuaranteedScanner| async move {
+      let output = scanner.scan(block).unwrap().not_additionally_locked().swap_remove(0);
       assert_eq!(output.transaction(), tx.hash());
       assert_eq!(output.commitment().amount, 5);
       assert_eq!(output.subaddress(), None);
@@ -100,9 +103,8 @@ test!(
       builder.add_payment(view.address(Network::Mainnet, Some(subaddress), None), 5);
       (builder.build().unwrap(), (scanner, subaddress))
     },
-    |rpc, block, tx: Transaction, _, mut state: (GuaranteedScanner, SubaddressIndex)| async move {
-      let output =
-        state.0.scan(&rpc, &block).await.unwrap().not_additionally_locked().swap_remove(0);
+    |_rpc: SRR, block, tx: Tx, _, mut state: (GuaranteedScanner, SubaddressIndex)| async move {
+      let output = state.0.scan(block).unwrap().not_additionally_locked().swap_remove(0);
       assert_eq!(output.transaction(), tx.hash());
       assert_eq!(output.commitment().amount, 5);
       assert_eq!(output.subaddress(), Some(state.1));
@@ -122,9 +124,8 @@ test!(
       builder.add_payment(view.address(Network::Mainnet, None, Some(payment_id)), 5);
       (builder.build().unwrap(), (scanner, payment_id))
     },
-    |rpc, block, tx: Transaction, _, mut state: (GuaranteedScanner, [u8; 8])| async move {
-      let output =
-        state.0.scan(&rpc, &block).await.unwrap().not_additionally_locked().swap_remove(0);
+    |_rpc: SRR, block, tx: Transaction, _, mut state: (GuaranteedScanner, [u8; 8])| async move {
+      let output = state.0.scan(block).unwrap().not_additionally_locked().swap_remove(0);
       assert_eq!(output.transaction(), tx.hash());
       assert_eq!(output.commitment().amount, 5);
       assert_eq!(output.payment_id(), Some(PaymentId::Encrypted(state.1)));
@@ -132,7 +133,6 @@ test!(
   ),
 );
 
-#[rustfmt::skip]
 test!(
   scan_guaranteed_integrated_subaddress,
   (
@@ -149,14 +149,8 @@ test!(
       builder.add_payment(view.address(Network::Mainnet, Some(subaddress), Some(payment_id)), 5);
       (builder.build().unwrap(), (scanner, payment_id, subaddress))
     },
-    |
-      rpc,
-      block,
-      tx: Transaction,
-      _,
-      mut state: (GuaranteedScanner, [u8; 8], SubaddressIndex),
-    | async move {
-      let output = state.0.scan(&rpc, &block).await.unwrap().not_additionally_locked().swap_remove(0);
+    |_rpc, block, tx: Tx, _, mut state: (GuaranteedScanner, [u8; 8], SubaddressIndex)| async move {
+      let output = state.0.scan(block).unwrap().not_additionally_locked().swap_remove(0);
       assert_eq!(output.transaction(), tx.hash());
       assert_eq!(output.commitment().amount, 5);
       assert_eq!(output.payment_id(), Some(PaymentId::Encrypted(state.1)));

networks/monero/wallet/tests/send.rs

@@ -4,13 +4,21 @@ use rand_core::OsRng;
 
 use monero_simple_request_rpc::SimpleRequestRpc;
 use monero_wallet::{
-  ringct::RctType, transaction::Transaction, rpc::Rpc, address::SubaddressIndex, extra::Extra,
+  ringct::RctType,
+  transaction::Transaction,
+  rpc::{ScannableBlock, Rpc},
+  address::SubaddressIndex,
+  extra::Extra,
   WalletOutput, OutputWithDecoys,
 };
 
 mod runner;
 use runner::{SignableTransactionBuilder, ring_len};
 
+#[allow(clippy::upper_case_acronyms)]
+type SRR = SimpleRequestRpc;
+type SB = ScannableBlock;
+
 // Set up inputs, select decoys, then add them to the TX builder
 async fn add_inputs(
   rct_type: RctType,
@@ -40,9 +48,8 @@ test!(
       builder.add_payment(addr, 5);
       (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);
+    |_rpc: SimpleRequestRpc, block, tx: Transaction, mut scanner: Scanner, ()| async move {
+      let output = scanner.scan(block).unwrap().not_additionally_locked().swap_remove(0);
       assert_eq!(output.transaction(), tx.hash());
       assert_eq!(output.commitment().amount, 5);
     },
@@ -57,8 +64,8 @@ test!(
       builder.add_payment(addr, 2000000000000);
       (builder.build().unwrap(), ())
     },
-    |rpc, block, tx: Transaction, mut scanner: Scanner, ()| async move {
-      let mut outputs = scanner.scan(&rpc, &block).await.unwrap().not_additionally_locked();
+    |_rpc: SimpleRequestRpc, block, tx: Transaction, mut scanner: Scanner, ()| async move {
+      let mut outputs = scanner.scan(block).unwrap().not_additionally_locked();
       assert_eq!(outputs.len(), 2);
       assert_eq!(outputs[0].transaction(), tx.hash());
       assert_eq!(outputs[0].transaction(), tx.hash());
@@ -74,9 +81,8 @@ test!(
       builder.add_payment(addr, 6);
       (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);
+    |_rpc: SimpleRequestRpc, block, tx: Transaction, mut scanner: Scanner, ()| async move {
+      let output = scanner.scan(block).unwrap().not_additionally_locked().swap_remove(0);
       assert_eq!(output.transaction(), tx.hash());
       assert_eq!(output.commitment().amount, 6);
     },
@@ -93,8 +99,8 @@ test!(
       builder.add_payment(addr, 1000000000000);
       (builder.build().unwrap(), ())
     },
-    |rpc, block, tx: Transaction, mut scanner: Scanner, ()| async move {
-      let outputs = scanner.scan(&rpc, &block).await.unwrap().not_additionally_locked();
+    |_rpc: SimpleRequestRpc, block, tx: Transaction, mut scanner: Scanner, ()| async move {
+      let outputs = scanner.scan(block).unwrap().not_additionally_locked();
       assert_eq!(outputs.len(), 1);
       assert_eq!(outputs[0].transaction(), tx.hash());
       assert_eq!(outputs[0].commitment().amount, 1000000000000);
@@ -130,17 +136,15 @@ test!(
         .add_payment(sub_view.subaddress(Network::Mainnet, SubaddressIndex::new(0, 1).unwrap()), 1);
       (builder.build().unwrap(), (change_view, sub_view))
     },
-    |rpc, block, tx: Transaction, _, views: (ViewPair, ViewPair)| async move {
+    |_rpc: SRR, block: SB, tx: Transaction, _, views: (ViewPair, ViewPair)| async move {
       // Make sure the change can pick up its output
       let mut change_scanner = Scanner::new(views.0);
-      assert!(
-        change_scanner.scan(&rpc, &block).await.unwrap().not_additionally_locked().len() == 1
-      );
+      assert!(change_scanner.scan(block.clone()).unwrap().not_additionally_locked().len() == 1);
 
       // Make sure the subaddress can pick up its output
       let mut sub_scanner = Scanner::new(views.1);
       sub_scanner.register_subaddress(SubaddressIndex::new(0, 1).unwrap());
-      let sub_outputs = sub_scanner.scan(&rpc, &block).await.unwrap().not_additionally_locked();
+      let sub_outputs = sub_scanner.scan(block).unwrap().not_additionally_locked();
       assert!(sub_outputs.len() == 1);
       assert_eq!(sub_outputs[0].transaction(), tx.hash());
       assert_eq!(sub_outputs[0].commitment().amount, 1);
@@ -165,8 +169,8 @@ test!(
       builder.add_payment(addr, 2000000000000);
       (builder.build().unwrap(), ())
     },
-    |rpc, block, tx: Transaction, mut scanner: Scanner, ()| async move {
-      let outputs = scanner.scan(&rpc, &block).await.unwrap().not_additionally_locked();
+    |_rpc: SimpleRequestRpc, block, tx: Transaction, mut scanner: Scanner, ()| async move {
+      let outputs = scanner.scan(block).unwrap().not_additionally_locked();
       assert_eq!(outputs.len(), 1);
       assert_eq!(outputs[0].transaction(), tx.hash());
       assert_eq!(outputs[0].commitment().amount, 2000000000000);
@@ -179,9 +183,8 @@ test!(
       builder.add_payment(addr, 2);
       (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);
+    |_rpc: SimpleRequestRpc, block, tx: Transaction, mut scanner: Scanner, ()| async move {
+      let output = scanner.scan(block).unwrap().not_additionally_locked().swap_remove(0);
       assert_eq!(output.transaction(), tx.hash());
       assert_eq!(output.commitment().amount, 2);
     },
@@ -195,8 +198,8 @@ test!(
       builder.add_payment(addr, 1000000000000);
       (builder.build().unwrap(), ())
     },
-    |rpc, block, tx: Transaction, mut scanner: Scanner, ()| async move {
-      let outputs = scanner.scan(&rpc, &block).await.unwrap().not_additionally_locked();
+    |_rpc: SimpleRequestRpc, block, tx: Transaction, mut scanner: Scanner, ()| async move {
+      let outputs = scanner.scan(block).unwrap().not_additionally_locked();
       assert_eq!(outputs.len(), 1);
       assert_eq!(outputs[0].transaction(), tx.hash());
       assert_eq!(outputs[0].commitment().amount, 1000000000000);
@@ -212,8 +215,8 @@ test!(
       }
       (builder.build().unwrap(), ())
     },
-    |rpc, block, tx: Transaction, mut scanner: Scanner, ()| async move {
-      let mut scanned_tx = scanner.scan(&rpc, &block).await.unwrap().not_additionally_locked();
+    |_rpc: SimpleRequestRpc, block, tx: Transaction, mut scanner: Scanner, ()| async move {
+      let mut scanned_tx = scanner.scan(block).unwrap().not_additionally_locked();
 
       let mut output_amounts = HashSet::new();
       for i in 0 .. 15 {
@@ -237,8 +240,8 @@ test!(
       builder.add_payment(addr, 1000000000000);
       (builder.build().unwrap(), ())
     },
-    |rpc, block, tx: Transaction, mut scanner: Scanner, ()| async move {
-      let outputs = scanner.scan(&rpc, &block).await.unwrap().not_additionally_locked();
+    |_rpc: SimpleRequestRpc, block, tx: Transaction, mut scanner: Scanner, ()| async move {
+      let outputs = scanner.scan(block).unwrap().not_additionally_locked();
       assert_eq!(outputs.len(), 1);
       assert_eq!(outputs[0].transaction(), tx.hash());
       assert_eq!(outputs[0].commitment().amount, 1000000000000);
@@ -263,10 +266,14 @@ test!(
 
       (builder.build().unwrap(), (scanner, subaddresses))
     },
-    |rpc, block, tx: Transaction, _, mut state: (Scanner, Vec<SubaddressIndex>)| async move {
+    |_rpc: SimpleRequestRpc,
+     block,
+     tx: Transaction,
+     _,
+     mut state: (Scanner, Vec<SubaddressIndex>)| async move {
       use std::collections::HashMap;
 
-      let mut scanned_tx = state.0.scan(&rpc, &block).await.unwrap().not_additionally_locked();
+      let mut scanned_tx = state.0.scan(block).unwrap().not_additionally_locked();
 
       let mut output_amounts_by_subaddress = HashMap::new();
       for i in 0 .. 15 {
@@ -294,8 +301,8 @@ test!(
       builder.add_payment(addr, 1000000000000);
       (builder.build().unwrap(), ())
     },
-    |rpc, block, tx: Transaction, mut scanner: Scanner, ()| async move {
-      let outputs = scanner.scan(&rpc, &block).await.unwrap().not_additionally_locked();
+    |_rpc: SimpleRequestRpc, block, tx: Transaction, mut scanner: Scanner, ()| async move {
+      let outputs = scanner.scan(block).unwrap().not_additionally_locked();
       assert_eq!(outputs.len(), 1);
       assert_eq!(outputs[0].transaction(), tx.hash());
       assert_eq!(outputs[0].commitment().amount, 1000000000000);
@@ -320,8 +327,8 @@ test!(
 
       (builder.build().unwrap(), ())
     },
-    |rpc, block, tx: Transaction, mut scanner: Scanner, ()| async move {
-      let mut outputs = scanner.scan(&rpc, &block).await.unwrap().not_additionally_locked();
+    |_rpc: SimpleRequestRpc, block, tx: Transaction, mut scanner: Scanner, ()| async move {
+      let mut outputs = scanner.scan(block).unwrap().not_additionally_locked();
       assert_eq!(outputs.len(), 2);
       assert_eq!(outputs[0].transaction(), tx.hash());
       assert_eq!(outputs[1].transaction(), tx.hash());
@@ -345,8 +352,8 @@ test!(
       builder.add_payment(addr, 1000000000000);
       (builder.build().unwrap(), ())
     },
-    |rpc, block, tx: Transaction, mut scanner: Scanner, ()| async move {
-      let outputs = scanner.scan(&rpc, &block).await.unwrap().not_additionally_locked();
+    |_rpc: SimpleRequestRpc, block, tx: Transaction, mut scanner: Scanner, ()| async move {
+      let outputs = scanner.scan(block).unwrap().not_additionally_locked();
       assert_eq!(outputs.len(), 1);
       assert_eq!(outputs[0].transaction(), tx.hash());
       assert_eq!(outputs[0].commitment().amount, 1000000000000);
@@ -381,11 +388,11 @@ test!(
       builder.add_payment(view.legacy_address(Network::Mainnet), 1);
       (builder.build().unwrap(), change_view)
     },
-    |rpc, block, _, _, change_view: ViewPair| async move {
+    |_rpc: SimpleRequestRpc, block, _, _, change_view: ViewPair| async move {
       // Make sure the change can pick up its output
       let mut change_scanner = Scanner::new(change_view);
       change_scanner.register_subaddress(SubaddressIndex::new(0, 1).unwrap());
-      let outputs = change_scanner.scan(&rpc, &block).await.unwrap().not_additionally_locked();
+      let outputs = change_scanner.scan(block).unwrap().not_additionally_locked();
       assert!(outputs.len() == 1);
       assert!(outputs[0].subaddress().unwrap().account() == 0);
       assert!(outputs[0].subaddress().unwrap().address() == 1);

networks/monero/wallet/tests/wallet2_compatibility.rs

@@ -106,6 +106,7 @@ async fn from_wallet_rpc_to_self(spec: AddressSpec) {
 
   // unlock it
   let block = runner::mine_until_unlocked(&daemon_rpc, &wallet_rpc_addr, tx_hash).await;
+  let block = daemon_rpc.get_scannable_block(block).await.unwrap();
 
   // Create the scanner
   let mut scanner = Scanner::new(view_pair);
@@ -114,8 +115,7 @@ async fn from_wallet_rpc_to_self(spec: AddressSpec) {
   }
 
   // Retrieve it and scan it
-  let output =
-    scanner.scan(&daemon_rpc, &block).await.unwrap().not_additionally_locked().swap_remove(0);
+  let output = scanner.scan(block).unwrap().not_additionally_locked().swap_remove(0);
   assert_eq!(output.transaction(), tx_hash);
 
   runner::check_weight_and_fee(&daemon_rpc.get_transaction(tx_hash).await.unwrap(), fee_rate);