feat(ckbtc): Use 25th percentile fee for UTXO consolidation (#8150)

Switch from median fee to 25th percentile fee when creating UTXO
consolidation transactions.

Author: ninegua

rs/bitcoin/ckbtc/minter/src/fees/mod.rs

@@ -3,6 +3,8 @@ use crate::tx::UnsignedTransaction;
 use crate::{Network, fake_sign};
 use ic_btc_interface::{MillisatoshiPerByte, Satoshi};
 use std::cmp::max;
+#[cfg(test)]
+mod tests;
 
 pub trait FeeEstimator {
     const DUST_LIMIT: u64;
@@ -14,6 +16,15 @@ pub trait FeeEstimator {
     fn estimate_median_fee(
         &self,
         fee_percentiles: &[MillisatoshiPerByte],
+    ) -> Option<MillisatoshiPerByte> {
+        self.estimate_nth_fee(fee_percentiles, 50)
+    }
+
+    /// Estimate the n-th percentile fees (n < 100) based on the given fee percentiles (slice of fee rates in milli base unit per vbyte/byte).
+    fn estimate_nth_fee(
+        &self,
+        fee_percentiles: &[MillisatoshiPerByte],
+        nth: usize,
     ) -> Option<MillisatoshiPerByte>;
 
     /// Evaluate the fee necessary to cover the minter's cycles consumption.
@@ -90,19 +101,20 @@ impl FeeEstimator for BitcoinFeeEstimator {
 
     const MIN_RELAY_FEE_RATE_INCREASE: MillisatoshiPerByte = 1_000;
 
-    fn estimate_median_fee(
+    fn estimate_nth_fee(
         &self,
         fee_percentiles: &[MillisatoshiPerByte],
+        nth: usize,
     ) -> Option<MillisatoshiPerByte> {
         /// The default fee we use on regtest networks.
         const DEFAULT_REGTEST_FEE: MillisatoshiPerByte = 5_000;
 
         let median_fee = match &self.network {
             Network::Mainnet | Network::Testnet => {
-                if fee_percentiles.len() < 100 {
+                if fee_percentiles.len() < 100 || nth >= 100 {
                     return None;
                 }
-                Some(fee_percentiles[50])
+                Some(fee_percentiles[nth])
             }
             Network::Regtest => Some(DEFAULT_REGTEST_FEE),
         };

rs/bitcoin/ckbtc/minter/src/fees/tests.rs

@@ -0,0 +1,17 @@
+use super::*;
+use crate::test_fixtures::bitcoin_fee_estimator;
+
+#[test]
+fn test_estimate_nth_fee() {
+    let estimator = bitcoin_fee_estimator();
+    let min_fee = estimator.minimum_fee_per_vbyte();
+    assert_eq!(estimator.estimate_nth_fee(&[], 10), None);
+    let percentiles = (1..=100).map(|i| i * 150).collect::<Vec<_>>();
+    for i in 0..100 {
+        assert_eq!(
+            estimator.estimate_nth_fee(&percentiles, i),
+            Some(percentiles[i].max(min_fee))
+        );
+    }
+    assert_eq!(estimator.estimate_nth_fee(&percentiles, 100), None);
+}

rs/bitcoin/ckbtc/minter/src/lib.rs

@@ -263,6 +263,34 @@ pub async fn estimate_fee_per_vbyte<R: CanisterRuntime>(
     }
 }
 
+/// Returns an estimate for transaction fees in the 25th percentile in millisatoshi per vbyte. Returns
+/// None if the Bitcoin canister is unavailable or does not have enough data for
+/// an estimate yet.
+pub async fn estimate_25th_fee_per_vbyte<R: CanisterRuntime>(
+    runtime: &R,
+) -> Option<MillisatoshiPerByte> {
+    let btc_network = state::read_state(|s| s.btc_network);
+    match runtime
+        .get_current_fee_percentiles(&bitcoin_canister::GetCurrentFeePercentilesRequest {
+            network: btc_network.into(),
+        })
+        .await
+    {
+        Ok(fees) => {
+            let fee_estimator = state::read_state(|s| runtime.fee_estimator(s));
+            fee_estimator.estimate_nth_fee(&fees, 25)
+        }
+        Err(err) => {
+            log!(
+                Priority::Info,
+                "[estimate_25th_fee_per_vbyte]: failed to get 25th percentile fee per vbyte: {}",
+                err
+            );
+            None
+        }
+    }
+}
+
 fn reimburse_canceled_requests<R: CanisterRuntime>(
     state: &mut state::CkBtcMinterState,
     requests: BTreeSet<state::RetrieveBtcRequest>,
@@ -1485,8 +1513,7 @@ pub async fn consolidate_utxos<R: CanisterRuntime>(
 
     let ecdsa_public_key = updates::get_btc_address::init_ecdsa_public_key().await;
 
-    // TODO DEFI-2552: use 25% percentile
-    let fee_millisatoshi_per_vbyte = estimate_fee_per_vbyte(runtime)
+    let fee_millisatoshi_per_vbyte = estimate_25th_fee_per_vbyte(runtime)
         .await
         .ok_or(ConsolidateUtxosError::EstimateFeeNotAvailable)?;
 

rs/bitcoin/ckbtc/minter/tests/tests.rs

@@ -2062,6 +2062,13 @@ fn test_utxo_consolidation_multiple() {
     );
     let transfer_index = result.0.to_u64().unwrap();
 
+    // Set fee percentiles so that the 25th percentile is 2000 and the median (50th) is 5000.
+    // We set the first 40 percentiles to 2000 and the rest to 5000.
+    let fees: Vec<u64> = std::iter::repeat_n(2000, 40)
+        .chain(std::iter::repeat_n(5000, 60))
+        .collect();
+    ckbtc.set_fee_percentiles(&fees);
+
     // Test two consolidations
     for i in 1..=2 {
         // Upgrade to trigger consolidation task by setting a lower threshold.
@@ -2115,6 +2122,18 @@ fn test_utxo_consolidation_multiple() {
         assert_eq!(fee_account_balance, new_fee_account_balance + burn_amount);
         fee_account_balance = new_fee_account_balance;
 
+        // Verify that the fee rate corresponds to the 25th percentile (2000).
+        // Since signatures length vary slightly, we check if the rate is close to 2000.
+        // It definitely shouldn't be close to 5000 (the median).
+        let tx_fee = total_input - total_output;
+        let vsize = tx.vsize();
+        let fee_rate = tx_fee * 1000 / vsize as u64;
+        assert!(
+            (1900..2100).contains(&fee_rate),
+            "Fee rate {} should be around 2000 (25th percentile), not 5000 (median)",
+            fee_rate
+        );
+
         // Finalize the new transaction.
         ckbtc.finalize_transaction(tx);
         assert_eq!(ckbtc.await_finalization(burn_index, 10), txid);

rs/dogecoin/ckdoge/minter/src/fees/mod.rs

@@ -49,15 +49,15 @@ impl FeeEstimator for DogecoinFeeEstimator {
     // corresponding to 10k millikoinus/byte
     const MIN_RELAY_FEE_RATE_INCREASE: u64 = 10_000;
 
-    fn estimate_median_fee(&self, fee_percentiles: &[u64]) -> Option<u64> {
+    fn estimate_nth_fee(&self, fee_percentiles: &[u64], nth: usize) -> Option<u64> {
         const DEFAULT_REGTEST_FEE: MillisatoshiPerByte = DogecoinFeeEstimator::DUST_LIMIT * 1_000;
 
         match &self.network {
             Network::Mainnet => {
-                if fee_percentiles.len() < 100 {
+                if fee_percentiles.len() < 100 || nth >= 100 {
                     return None;
                 }
-                Some(fee_percentiles[50])
+                Some(fee_percentiles[nth])
             }
             Network::Regtest => Some(DEFAULT_REGTEST_FEE),
         }