Diversify ViewPair/Scanner into ViewPair/GuaranteedViewPair and Scanner/GuaranteedScanner

Also cleans the Scanner impl.

coins/monero/rpc/src/lib.rs

@@ -32,6 +32,38 @@ use monero_serai::{
 //   src/wallet/wallet2.cpp#L121
 const GRACE_BLOCKS_FOR_FEE_ESTIMATE: u64 = 10;
 
+/// An error from the RPC.
+#[derive(Clone, PartialEq, Eq, Debug)]
+#[cfg_attr(feature = "std", derive(thiserror::Error))]
+pub enum RpcError {
+  /// An internal error.
+  #[cfg_attr(feature = "std", error("internal error ({0})"))]
+  InternalError(String),
+  /// A connection error with the node.
+  #[cfg_attr(feature = "std", error("connection error ({0})"))]
+  ConnectionError(String),
+  /// The node is invalid per the expected protocol.
+  #[cfg_attr(feature = "std", error("invalid node ({0})"))]
+  InvalidNode(String),
+  /// Requested transactions weren't found.
+  #[cfg_attr(feature = "std", error("transactions not found"))]
+  TransactionsNotFound(Vec<[u8; 32]>),
+  /// The transaction was pruned.
+  ///
+  /// Pruned transactions are not supported at this time.
+  #[cfg_attr(feature = "std", error("pruned transaction"))]
+  PrunedTransaction,
+  /// A transaction (sent or received) was invalid.
+  #[cfg_attr(feature = "std", error("invalid transaction ({0:?})"))]
+  InvalidTransaction([u8; 32]),
+  /// The returned fee was unusable.
+  #[cfg_attr(feature = "std", error("unexpected fee response"))]
+  InvalidFee,
+  /// The priority intended for use wasn't usable.
+  #[cfg_attr(feature = "std", error("invalid priority"))]
+  InvalidPriority,
+}
+
 /// A struct containing a fee rate.
 ///
 /// The fee rate is defined as a per-weight cost, along with a mask for rounding purposes.
@@ -147,7 +179,7 @@ struct TransactionsResponse {
 #[derive(Deserialize, Debug)]
 pub struct OutputResponse {
   /// The height of the block this output was added to the chain in.
-  pub height: u32,
+  pub height: usize,
   /// If the output is unlocked, per the node's local view.
   pub unlocked: bool,
   /// The output's key.
@@ -158,38 +190,6 @@ pub struct OutputResponse {
   pub txid: String,
 }
 
-/// An error from the RPC.
-#[derive(Clone, PartialEq, Eq, Debug)]
-#[cfg_attr(feature = "std", derive(thiserror::Error))]
-pub enum RpcError {
-  /// An internal error.
-  #[cfg_attr(feature = "std", error("internal error ({0})"))]
-  InternalError(&'static str),
-  /// A connection error with the node.
-  #[cfg_attr(feature = "std", error("connection error ({0})"))]
-  ConnectionError(String),
-  /// The node is invalid per the expected protocol.
-  #[cfg_attr(feature = "std", error("invalid node ({0})"))]
-  InvalidNode(String),
-  /// Requested transactions weren't found.
-  #[cfg_attr(feature = "std", error("transactions not found"))]
-  TransactionsNotFound(Vec<[u8; 32]>),
-  /// The transaction was pruned.
-  ///
-  /// Pruned transactions are not supported at this time.
-  #[cfg_attr(feature = "std", error("pruned transaction"))]
-  PrunedTransaction,
-  /// A transaction (sent or received) was invalid.
-  #[cfg_attr(feature = "std", error("invalid transaction ({0:?})"))]
-  InvalidTransaction([u8; 32]),
-  /// The returned fee was unusable.
-  #[cfg_attr(feature = "std", error("unexpected fee response"))]
-  InvalidFee,
-  /// The priority intended for use wasn't usable.
-  #[cfg_attr(feature = "std", error("invalid priority"))]
-  InvalidPriority,
-}
-
 fn rpc_hex(value: &str) -> Result<Vec<u8>, RpcError> {
   hex::decode(value).map_err(|_| RpcError::InvalidNode("expected hex wasn't hex".to_string()))
 }
@@ -309,10 +309,10 @@ pub trait Rpc: Sync + Clone + Debug {
   ///
   /// The height is defined as the amount of blocks on the blockchain. For a blockchain with only
   /// its genesis block, the height will be 1.
-  async fn get_height(&self) -> Result<u32, RpcError> {
+  async fn get_height(&self) -> Result<usize, RpcError> {
     #[derive(Deserialize, Debug)]
     struct HeightResponse {
-      height: u32,
+      height: usize,
     }
     Ok(self.rpc_call::<Option<()>, HeightResponse>("get_height", None).await?.height)
   }
@@ -397,7 +397,7 @@ pub trait Rpc: Sync + Clone + Debug {
   ///
   /// `number` is the block's zero-indexed position on the blockchain (`0` for the genesis block,
   /// `height - 1` for the latest block).
-  async fn get_block_hash(&self, number: u32) -> Result<[u8; 32], RpcError> {
+  async fn get_block_hash(&self, number: usize) -> Result<[u8; 32], RpcError> {
     #[derive(Deserialize, Debug)]
     struct BlockHeaderResponse {
       hash: String,
@@ -436,7 +436,7 @@ pub trait Rpc: Sync + Clone + Debug {
   ///
   /// `number` is the block's zero-indexed position on the blockchain (`0` for the genesis block,
   /// `height - 1` for the latest block).
-  async fn get_block_by_number(&self, number: u32) -> Result<Block, RpcError> {
+  async fn get_block_by_number(&self, number: usize) -> Result<Block, RpcError> {
     #[derive(Deserialize, Debug)]
     struct BlockResponse {
       blob: String,
@@ -449,16 +449,16 @@ pub trait Rpc: Sync + Clone + Debug {
       .map_err(|_| RpcError::InvalidNode("invalid block".to_string()))?;
 
     // Make sure this is actually the block for this number
-    match block.miner_tx.prefix().inputs.first() {
+    match block.miner_transaction.prefix().inputs.first() {
       Some(Input::Gen(actual)) => {
-        if u32::try_from(*actual) == Ok(number) {
+        if usize::try_from(*actual) == Ok(number) {
           Ok(block)
         } else {
           Err(RpcError::InvalidNode("different block than requested (number)".to_string()))
         }
       }
       _ => Err(RpcError::InvalidNode(
-        "block's miner_tx didn't have an input of kind Input::Gen".to_string(),
+        "block's miner_transaction didn't have an input of kind Input::Gen".to_string(),
       )),
     }
   }
@@ -471,8 +471,8 @@ pub trait Rpc: Sync + Clone + Debug {
   /// block's header.
   async fn get_block_transactions(&self, hash: [u8; 32]) -> Result<Vec<Transaction>, RpcError> {
     let block = self.get_block(hash).await?;
-    let mut res = vec![block.miner_tx];
-    res.extend(self.get_transactions(&block.txs).await?);
+    let mut res = vec![block.miner_transaction];
+    res.extend(self.get_transactions(&block.transactions).await?);
     Ok(res)
   }
 
@@ -484,7 +484,7 @@ pub trait Rpc: Sync + Clone + Debug {
   /// block's header.
   async fn get_block_transactions_by_number(
     &self,
-    number: u32,
+    number: usize,
   ) -> Result<Vec<Transaction>, RpcError> {
     self.get_block_transactions(self.get_block_hash(number).await?).await
   }
@@ -647,7 +647,7 @@ pub trait Rpc: Sync + Clone + Debug {
   /// Get the output distribution.
   ///
   /// `from` and `to` are heights, not block numbers, and inclusive.
-  async fn get_output_distribution(&self, from: u32, to: u32) -> Result<Vec<u64>, RpcError> {
+  async fn get_output_distribution(&self, from: usize, to: usize) -> Result<Vec<u64>, RpcError> {
     #[derive(Deserialize, Debug)]
     struct Distribution {
       distribution: Vec<u64>,
@@ -716,7 +716,7 @@ pub trait Rpc: Sync + Clone + Debug {
   async fn get_unlocked_outputs(
     &self,
     indexes: &[u64],
-    height: u32,
+    height: usize,
     fingerprintable_canonical: bool,
   ) -> Result<Vec<Option<[EdwardsPoint; 2]>>, RpcError> {
     let outs: Vec<OutputResponse> = self.get_outs(indexes).await?;
@@ -857,11 +857,11 @@ pub trait Rpc: Sync + Clone + Debug {
     &self,
     address: &str,
     block_count: usize,
-  ) -> Result<(Vec<[u8; 32]>, u32), RpcError> {
+  ) -> Result<(Vec<[u8; 32]>, usize), RpcError> {
     #[derive(Debug, Deserialize)]
     struct BlocksResponse {
       blocks: Vec<String>,
-      height: u32,
+      height: usize,
     }
 
     let res = self