Remove Fee from the Network API

The only benefit to having it would be the ability to cache it across
prepare_send, which can be done internally to the Network.

processor/src/networks/bitcoin.rs

@@ -249,11 +249,6 @@ impl BlockTrait<Bitcoin> for Block {
   fn time(&self) -> u64 {
     self.header.time.into()
   }
-
-  fn median_fee(&self) -> Fee {
-    // TODO
-    Fee(20)
-  }
 }
 
 const KEY_DST: &[u8] = b"Serai Bitcoin Output Offset";
@@ -322,12 +317,21 @@ impl Bitcoin {
 
   async fn make_signable_transaction(
     &self,
+    block_number: usize,
     inputs: &[Output],
     payments: &[Payment<Self>],
     change: &Option<Address>,
-    fee: Fee,
     calculating_fee: bool,
-  ) -> Option<BSignableTransaction> {
+  ) -> Result<Option<BSignableTransaction>, NetworkError> {
+    // TODO2: Use an fee representative of several blocks, cached inside Self
+    let block_for_fee = self.get_block(block_number).await?;
+    let median_fee = || {
+      // TODO
+      let _ = block_for_fee;
+      Fee(20)
+    };
+    let fee = median_fee();
+
     let payments = payments
       .iter()
       .map(|payment| {
@@ -348,22 +352,20 @@ impl Bitcoin {
       None,
       fee.0,
     ) {
-      Ok(signable) => Some(signable),
+      Ok(signable) => Ok(Some(signable)),
       Err(TransactionError::NoInputs) => {
         panic!("trying to create a bitcoin transaction without inputs")
       }
       // No outputs left and the change isn't worth enough
-      Err(TransactionError::NoOutputs) => None,
+      Err(TransactionError::NoOutputs) => Ok(None),
       // amortize_fee removes payments which fall below the dust threshold
       Err(TransactionError::DustPayment) => panic!("dust payment despite removing dust"),
       Err(TransactionError::TooMuchData) => panic!("too much data despite not specifying data"),
       Err(TransactionError::TooLowFee) => {
         panic!("created a transaction whose fee is below the minimum")
       }
-      Err(TransactionError::NotEnoughFunds) => {
-        // Mot even enough funds to pay the fee
-        None
-      }
+      // Mot even enough funds to pay the fee
+      Err(TransactionError::NotEnoughFunds) => Ok(None),
       Err(TransactionError::TooLargeTransaction) => {
         panic!("created a too large transaction despite limiting inputs/outputs")
       }
@@ -375,7 +377,6 @@ impl Bitcoin {
 impl Network for Bitcoin {
   type Curve = Secp256k1;
 
-  type Fee = Fee;
   type Transaction = Transaction;
   type Block = Block;
 
@@ -555,31 +556,29 @@ impl Network for Bitcoin {
 
   async fn needed_fee(
     &self,
-    _: usize,
+    block_number: usize,
     _: &[u8; 32],
     inputs: &[Output],
     payments: &[Payment<Self>],
     change: &Option<Address>,
-    fee_rate: Fee,
   ) -> Result<Option<u64>, NetworkError> {
     Ok(
       self
-        .make_signable_transaction(inputs, payments, change, fee_rate, true)
-        .await
+        .make_signable_transaction(block_number, inputs, payments, change, true)
+        .await?
         .map(|signable| signable.needed_fee()),
     )
   }
 
   async fn signable_transaction(
     &self,
-    _: usize,
+    block_number: usize,
     plan_id: &[u8; 32],
     inputs: &[Output],
     payments: &[Payment<Self>],
     change: &Option<Address>,
-    fee_rate: Fee,
   ) -> Result<Option<(Self::SignableTransaction, Self::Eventuality)>, NetworkError> {
-    Ok(self.make_signable_transaction(inputs, payments, change, fee_rate, false).await.map(
+    Ok(self.make_signable_transaction(block_number, inputs, payments, change, false).await?.map(
       |signable| {
         let mut transcript =
           RecommendedTranscript::new(b"Serai Processor Bitcoin Transaction Transcript");
@@ -635,11 +634,6 @@ impl Network for Bitcoin {
     self.rpc.get_block_number(id).await.unwrap()
   }
 
-  #[cfg(test)]
-  async fn get_fee(&self) -> Fee {
-    Fee(1)
-  }
-
   #[cfg(test)]
   async fn mine_block(&self) {
     self

processor/src/networks/mod.rs

@@ -189,7 +189,6 @@ pub trait Block<N: Network>: Send + Sync + Sized + Clone + Debug {
   fn parent(&self) -> Self::Id;
   // The monotonic network time at this block.
   fn time(&self) -> u64;
-  fn median_fee(&self) -> N::Fee;
 }
 
 // The post-fee value of an expected branch.
@@ -225,10 +224,6 @@ pub trait Network: 'static + Send + Sync + Clone + PartialEq + Eq + Debug {
   /// The elliptic curve used for this network.
   type Curve: Curve;
 
-  /// The type representing the fee for this network.
-  // This should likely be a u64, wrapped in a type which implements appropriate fee logic.
-  type Fee: Send + Copy;
-
   /// The type representing the transaction for this network.
   type Transaction: Transaction<Self>;
   /// The type representing the block for this network.
@@ -322,7 +317,6 @@ pub trait Network: 'static + Send + Sync + Clone + PartialEq + Eq + Debug {
     inputs: &[Self::Output],
     payments: &[Payment<Self>],
     change: &Option<Self::Address>,
-    fee_rate: Self::Fee,
   ) -> Result<Option<u64>, NetworkError>;
 
   /// Create a SignableTransaction for the given Plan.
@@ -338,7 +332,6 @@ pub trait Network: 'static + Send + Sync + Clone + PartialEq + Eq + Debug {
     inputs: &[Self::Output],
     payments: &[Payment<Self>],
     change: &Option<Self::Address>,
-    fee_rate: Self::Fee,
   ) -> Result<Option<(Self::SignableTransaction, Self::Eventuality)>, NetworkError>;
 
   /// Prepare a SignableTransaction for a transaction.
@@ -346,7 +339,6 @@ pub trait Network: 'static + Send + Sync + Clone + PartialEq + Eq + Debug {
     &self,
     block_number: usize,
     plan: Plan<Self>,
-    fee_rate: Self::Fee,
     operating_costs: u64,
   ) -> Result<PreparedSend<Self>, NetworkError> {
     // Sanity check this has at least one output planned
@@ -357,8 +349,7 @@ pub trait Network: 'static + Send + Sync + Clone + PartialEq + Eq + Debug {
     let theoretical_change_amount = inputs.iter().map(|input| input.amount()).sum::<u64>() -
       payments.iter().map(|payment| payment.amount).sum::<u64>();
 
-    let Some(tx_fee) =
-      self.needed_fee(block_number, &plan_id, &inputs, &payments, &change, fee_rate).await?
+    let Some(tx_fee) = self.needed_fee(block_number, &plan_id, &inputs, &payments, &change).await?
     else {
       // This Plan is not fulfillable
       // TODO: Have Plan explicitly distinguish payments and branches in two separate Vecs?
@@ -462,9 +453,8 @@ pub trait Network: 'static + Send + Sync + Clone + PartialEq + Eq + Debug {
       )
     })();
 
-    let Some(tx) = self
-      .signable_transaction(block_number, &plan_id, &inputs, &payments, &change, fee_rate)
-      .await?
+    let Some(tx) =
+      self.signable_transaction(block_number, &plan_id, &inputs, &payments, &change).await?
     else {
       panic!(
         "{}. {}: {}, {}: {:?}, {}: {:?}, {}: {:?}, {}: {}",
@@ -525,9 +515,6 @@ pub trait Network: 'static + Send + Sync + Clone + PartialEq + Eq + Debug {
   #[cfg(test)]
   async fn get_block_number(&self, id: &<Self::Block as Block<Self>>::Id) -> usize;
 
-  #[cfg(test)]
-  async fn get_fee(&self) -> Self::Fee;
-
   #[cfg(test)]
   async fn mine_block(&self);
 

processor/src/networks/monero.rs

@@ -161,11 +161,6 @@ impl BlockTrait<Monero> for Block {
   fn time(&self) -> u64 {
     self.header.timestamp
   }
-
-  fn median_fee(&self) -> Fee {
-    // TODO
-    Fee { per_weight: 10000000, mask: 10000 }
-  }
 }
 
 #[derive(Clone, Debug)]
@@ -206,7 +201,6 @@ impl Monero {
     scanner
   }
 
-  #[allow(clippy::too_many_arguments)]
   async fn make_signable_transaction(
     &self,
     block_number: usize,
@@ -214,9 +208,17 @@ impl Monero {
     inputs: &[Output],
     payments: &[Payment<Self>],
     change: &Option<Address>,
-    fee_rate: Fee,
     calculating_fee: bool,
   ) -> Result<Option<(RecommendedTranscript, MSignableTransaction)>, NetworkError> {
+    // TODO2: Use an fee representative of several blocks, cached inside Self
+    let block_for_fee = self.get_block(block_number).await?;
+    let median_fee = || {
+      // TODO
+      let _ = block_for_fee;
+      Fee { per_weight: 10000000, mask: 10000 }
+    };
+    let fee_rate = median_fee();
+
     // Get the protocol for the specified block number
     // For now, this should just be v16, the latest deployed protocol, since there's no upcoming
     // hard fork to be mindful of
@@ -352,7 +354,6 @@ impl Monero {
 impl Network for Monero {
   type Curve = Ed25519;
 
-  type Fee = Fee;
   type Transaction = Transaction;
   type Block = Block;
 
@@ -525,11 +526,10 @@ impl Network for Monero {
     inputs: &[Output],
     payments: &[Payment<Self>],
     change: &Option<Address>,
-    fee_rate: Fee,
   ) -> Result<Option<u64>, NetworkError> {
     Ok(
       self
-        .make_signable_transaction(block_number, plan_id, inputs, payments, change, fee_rate, true)
+        .make_signable_transaction(block_number, plan_id, inputs, payments, change, true)
         .await?
         .map(|(_, signable)| signable.fee()),
     )
@@ -542,11 +542,10 @@ impl Network for Monero {
     inputs: &[Output],
     payments: &[Payment<Self>],
     change: &Option<Address>,
-    fee_rate: Fee,
   ) -> Result<Option<(Self::SignableTransaction, Self::Eventuality)>, NetworkError> {
     Ok(
       self
-        .make_signable_transaction(block_number, plan_id, inputs, payments, change, fee_rate, false)
+        .make_signable_transaction(block_number, plan_id, inputs, payments, change, false)
         .await?
         .map(|(transcript, signable)| {
           let signable = SignableTransaction { transcript, actual: signable };
@@ -590,13 +589,6 @@ impl Network for Monero {
     self.rpc.get_block(*id).await.unwrap().number()
   }
 
-  #[cfg(test)]
-  async fn get_fee(&self) -> Fee {
-    use monero_serai::wallet::FeePriority;
-
-    self.rpc.get_fee(self.rpc.get_protocol().await.unwrap(), FeePriority::Low).await.unwrap()
-  }
-
   #[cfg(test)]
   async fn mine_block(&self) {
     // https://github.com/serai-dex/serai/issues/198