Update monero-wallet tests to compile

Some are _consistently_ failing due to the inputs we attempt to spend being too
young. I'm unsure what's up with that. Most seem to pass _consistently_,
implying it's not a random issue yet some configuration/env aspect.

coins/monero/wallet/src/decoys.rs

@@ -32,7 +32,7 @@ async fn select_n<'a, R: RngCore + CryptoRng>(
   fingerprintable_canonical: bool,
 ) -> Result<Vec<(u64, [EdwardsPoint; 2])>, RpcError> {
   // TODO: consider removing this extra RPC and expect the caller to handle it
-  if fingerprintable_canonical && height > rpc.get_height().await? {
+  if fingerprintable_canonical && (height > rpc.get_height().await?) {
     // TODO: Don't use InternalError for the caller's failure
     Err(RpcError::InternalError("decoys being requested from too young blocks"))?;
   }

coins/monero/wallet/src/old_send/builder.rs

@@ -1,140 +0,0 @@
-use std::sync::{Arc, RwLock};
-
-use zeroize::{Zeroize, ZeroizeOnDrop, Zeroizing};
-
-use crate::{
-  WalletProtocol, address::MoneroAddress, FeeRate, SpendableOutput, Change, Decoys, SignableTransaction,
-  TransactionError, extra::MAX_ARBITRARY_DATA_SIZE,
-};
-
-#[derive(Clone, PartialEq, Eq, Debug, Zeroize, ZeroizeOnDrop)]
-struct SignableTransactionBuilderInternal {
-  protocol: WalletProtocol,
-  fee_rate: FeeRate,
-  r_seed: Option<Zeroizing<[u8; 32]>>,
-  inputs: Vec<(SpendableOutput, Decoys)>,
-  payments: Vec<(MoneroAddress, u64)>,
-  change_address: Change,
-  data: Vec<Vec<u8>>,
-}
-
-impl SignableTransactionBuilderInternal {
-  // Takes in the change address so users don't miss that they have to manually set one
-  // If they don't, all leftover funds will become part of the fee
-  fn new(protocol: WalletProtocol, fee_rate: FeeRate, change_address: Change) -> Self {
-    Self {
-      protocol,
-      fee_rate,
-      r_seed: None,
-      inputs: vec![],
-      payments: vec![],
-      change_address,
-      data: vec![],
-    }
-  }
-
-  fn set_r_seed(&mut self, r_seed: Zeroizing<[u8; 32]>) {
-    self.r_seed = Some(r_seed);
-  }
-
-  fn add_input(&mut self, input: (SpendableOutput, Decoys)) {
-    self.inputs.push(input);
-  }
-  fn add_inputs(&mut self, inputs: &[(SpendableOutput, Decoys)]) {
-    self.inputs.extend(inputs.iter().cloned());
-  }
-
-  fn add_payment(&mut self, dest: MoneroAddress, amount: u64) {
-    self.payments.push((dest, amount));
-  }
-  fn add_payments(&mut self, payments: &[(MoneroAddress, u64)]) {
-    self.payments.extend(payments);
-  }
-
-  fn add_data(&mut self, data: Vec<u8>) {
-    self.data.push(data);
-  }
-}
-
-/// A Transaction Builder for Monero transactions.
-/// All methods provided will modify self while also returning a shallow copy, enabling efficient
-/// chaining with a clean API.
-/// In order to fork the builder at some point, clone will still return a deep copy.
-#[derive(Debug)]
-pub struct SignableTransactionBuilder(Arc<RwLock<SignableTransactionBuilderInternal>>);
-impl Clone for SignableTransactionBuilder {
-  fn clone(&self) -> Self {
-    Self(Arc::new(RwLock::new((*self.0.read().unwrap()).clone())))
-  }
-}
-
-impl PartialEq for SignableTransactionBuilder {
-  fn eq(&self, other: &Self) -> bool {
-    *self.0.read().unwrap() == *other.0.read().unwrap()
-  }
-}
-impl Eq for SignableTransactionBuilder {}
-
-impl Zeroize for SignableTransactionBuilder {
-  fn zeroize(&mut self) {
-    self.0.write().unwrap().zeroize()
-  }
-}
-
-impl SignableTransactionBuilder {
-  fn shallow_copy(&self) -> Self {
-    Self(self.0.clone())
-  }
-
-  pub fn new(protocol: WalletProtocol, fee_rate: FeeRate, change_address: Change) -> Self {
-    Self(Arc::new(RwLock::new(SignableTransactionBuilderInternal::new(
-      protocol,
-      fee_rate,
-      change_address,
-    ))))
-  }
-
-  pub fn set_r_seed(&mut self, r_seed: Zeroizing<[u8; 32]>) -> Self {
-    self.0.write().unwrap().set_r_seed(r_seed);
-    self.shallow_copy()
-  }
-
-  pub fn add_input(&mut self, input: (SpendableOutput, Decoys)) -> Self {
-    self.0.write().unwrap().add_input(input);
-    self.shallow_copy()
-  }
-  pub fn add_inputs(&mut self, inputs: &[(SpendableOutput, Decoys)]) -> Self {
-    self.0.write().unwrap().add_inputs(inputs);
-    self.shallow_copy()
-  }
-
-  pub fn add_payment(&mut self, dest: MoneroAddress, amount: u64) -> Self {
-    self.0.write().unwrap().add_payment(dest, amount);
-    self.shallow_copy()
-  }
-  pub fn add_payments(&mut self, payments: &[(MoneroAddress, u64)]) -> Self {
-    self.0.write().unwrap().add_payments(payments);
-    self.shallow_copy()
-  }
-
-  pub fn add_data(&mut self, data: Vec<u8>) -> Result<Self, TransactionError> {
-    if data.len() > MAX_ARBITRARY_DATA_SIZE {
-      Err(TransactionError::TooMuchData)?;
-    }
-    self.0.write().unwrap().add_data(data);
-    Ok(self.shallow_copy())
-  }
-
-  pub fn build(self) -> Result<SignableTransaction, TransactionError> {
-    let read = self.0.read().unwrap();
-    SignableTransaction::new(
-      read.protocol,
-      read.r_seed.clone(),
-      read.inputs.clone(),
-      read.payments.clone(),
-      &read.change_address,
-      read.data.clone(),
-      read.fee_rate,
-    )
-  }
-}

coins/monero/wallet/src/send/mod.rs

@@ -321,11 +321,27 @@ impl SignableTransaction {
       }
     }
 
-    let res = SignableTransaction { rct_type, sender_view_key, inputs, payments, data, fee_rate };
+    let mut res =
+      SignableTransaction { rct_type, sender_view_key, inputs, payments, data, fee_rate };
     res.validate()?;
+
+    // Shuffle the payments
+    {
+      let mut rng = res.seeded_rng(b"shuffle_payments");
+      res.payments.shuffle(&mut rng);
+    }
+
     Ok(res)
   }
 
+  pub fn fee_rate(&self) -> FeeRate {
+    self.fee_rate
+  }
+
+  pub fn fee(&self) -> u64 {
+    self.weight_and_fee().1
+  }
+
   pub fn write<W: io::Write>(&self, w: &mut W) -> io::Result<()> {
     fn write_input<W: io::Write>(input: &(SpendableOutput, Decoys), w: &mut W) -> io::Result<()> {
       input.0.write(w)?;
@@ -424,12 +440,6 @@ impl SignableTransaction {
       key_images.push(key_image);
     }
 
-    // Shuffle the payments
-    {
-      let mut rng = self.seeded_rng(b"shuffle_payments");
-      self.payments.shuffle(&mut rng);
-    }
-
     SignableTransactionWithKeyImages { intent: self, key_images }
   }