Merge branch 'leo-variable-min-w-amount' into 'master'

feat(ckBTC) Variable minimum retrieval amount.

There is the risk that the median fee rate may become so large that the fee exceeds the minimum retrieve amount of 100,000 satoshi.

This problem can be addressed by making the minimum retrieve amount dependent on the current median fee rate. As outlined here, a solution is to introduce a “buffer” so that the minimum retrieve amount is always considerably larger than the fee in practice:

`min_retrieve_amount = ((22_100 + 221 * median_fee_rate + 305 + 2000) / 50_000) * 50_000 + 100_000`

Closes FI-730. 

Closes FI-730

See merge request dfinity-lab/public/ic!12536

Author: leokazz

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

@@ -121,6 +121,24 @@ async fn fetch_main_utxos(main_account: &Account, main_address: &BitcoinAddress)
     })
 }
 
+/// Returns the minimum withdrawal amount based on the current median fee rate (in millisatoshi per byte).
+/// The returned amount is in satoshi.
+fn compute_min_withdrawal_amount(median_fee_rate_e3s: MillisatoshiPerByte) -> u64 {
+    const PER_REQUEST_RBF_BOUND: u64 = 22_100;
+    const PER_REQUEST_VSIZE_BOUND: u64 = 221;
+    const PER_REQUEST_MINTER_FEE_BOUND: u64 = 305;
+    const PER_REQUEST_KYT_FEE: u64 = 2_000;
+
+    let median_fee_rate = median_fee_rate_e3s / 1_000;
+    ((PER_REQUEST_RBF_BOUND
+        + PER_REQUEST_VSIZE_BOUND * median_fee_rate
+        + PER_REQUEST_MINTER_FEE_BOUND
+        + PER_REQUEST_KYT_FEE)
+        / 50_000)
+        * 50_000
+        + 100_000
+}
+
 /// Returns an estimate for transaction fees in millisatoshi per vbyte.  Returns
 /// None if the bitcoin canister is unavailable or does not have enough data for
 /// an estimate yet.
@@ -136,7 +154,10 @@ pub async fn estimate_fee_per_vbyte() -> Option<MillisatoshiPerByte> {
                 return Some(DEFAULT_FEE);
             }
             if fees.len() >= 100 {
-                state::mutate_state(|s| s.last_fee_per_vbyte = fees.clone());
+                state::mutate_state(|s| {
+                    s.last_fee_per_vbyte = fees.clone();
+                    s.retrieve_btc_min_amount = compute_min_withdrawal_amount(fees[50]);
+                });
                 Some(fees[50])
             } else {
                 log!(

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

@@ -12,6 +12,7 @@ use ic_ckbtc_minter::state::{Mode, RetrieveBtcStatus};
 use ic_ckbtc_minter::updates::get_btc_address::GetBtcAddressArgs;
 use ic_ckbtc_minter::updates::retrieve_btc::{RetrieveBtcArgs, RetrieveBtcError, RetrieveBtcOk};
 use ic_ckbtc_minter::updates::update_balance::{UpdateBalanceArgs, UpdateBalanceError, UtxoStatus};
+use ic_ckbtc_minter::MinterInfo;
 use ic_icrc1_ledger::{ArchiveOptions, InitArgs as LedgerInitArgs, LedgerArgument};
 use ic_state_machine_tests::{Cycles, StateMachine, StateMachineBuilder, WasmResult};
 use ic_test_utilities_load_wasm::load_wasm;
@@ -495,7 +496,7 @@ impl CkBtcSetup {
         env.execute_ingress(
             bitcoin_id,
             "set_fee_percentiles",
-            Encode!(&(1..=100).collect::<Vec<u64>>()).unwrap(),
+            Encode!(&(1..=100).map(|i| i * 100).collect::<Vec<u64>>()).unwrap(),
         )
         .expect("failed to set fee percentiles");
 
@@ -520,6 +521,16 @@ impl CkBtcSetup {
         }
     }
 
+    pub fn set_fee_percentiles(&self, fees: &Vec<u64>) {
+        self.env
+            .execute_ingress(
+                self.bitcoin_id,
+                "set_fee_percentiles",
+                Encode!(fees).unwrap(),
+            )
+            .expect("failed to set fee percentiles");
+    }
+
     pub fn push_utxo(&self, address: String, utxo: Utxo) {
         assert_reply(
             self.env
@@ -554,7 +565,19 @@ impl CkBtcSetup {
         .unwrap()
     }
 
-    pub fn estimate_withdrawal_fee(&self, amount: Option<u64>) -> WithdrawalFee {
+    pub fn get_minter_info(&self) -> MinterInfo {
+        Decode!(
+            &assert_reply(
+                self.env
+                    .execute_ingress(self.minter_id, "get_minter_info", Encode!().unwrap(),)
+                    .expect("failed to get minter info")
+            ),
+            MinterInfo
+        )
+        .unwrap()
+    }
+
+    pub fn refresh_fee_percentiles(&self) {
         Decode!(
             &assert_reply(
                 self.env
@@ -569,7 +592,10 @@ impl CkBtcSetup {
             ()
         )
         .unwrap();
+    }
 
+    pub fn estimate_withdrawal_fee(&self, amount: Option<u64>) -> WithdrawalFee {
+        self.refresh_fee_percentiles();
         Decode!(
             &assert_reply(
                 self.env
@@ -843,3 +869,33 @@ fn test_transaction_finalization() {
 
     assert_eq!(ckbtc.await_finalization(block_index, 10), txid);
 }
+
+#[test]
+fn test_min_retrieval_amount() {
+    let ckbtc = CkBtcSetup::new();
+
+    ckbtc.refresh_fee_percentiles();
+    let retrieve_btc_min_amount = ckbtc.get_minter_info().retrieve_btc_min_amount;
+    assert_eq!(retrieve_btc_min_amount, 100_000);
+
+    // The numbers used in this test have been re-computed using a python script using integers.
+    ckbtc.set_fee_percentiles(&vec![0; 100]);
+    ckbtc.refresh_fee_percentiles();
+    let retrieve_btc_min_amount = ckbtc.get_minter_info().retrieve_btc_min_amount;
+    assert_eq!(retrieve_btc_min_amount, 100_000);
+
+    ckbtc.set_fee_percentiles(&vec![116_000; 100]);
+    ckbtc.refresh_fee_percentiles();
+    let retrieve_btc_min_amount = ckbtc.get_minter_info().retrieve_btc_min_amount;
+    assert_eq!(retrieve_btc_min_amount, 150_000);
+
+    ckbtc.set_fee_percentiles(&vec![342_000; 100]);
+    ckbtc.refresh_fee_percentiles();
+    let retrieve_btc_min_amount = ckbtc.get_minter_info().retrieve_btc_min_amount;
+    assert_eq!(retrieve_btc_min_amount, 150_000);
+
+    ckbtc.set_fee_percentiles(&vec![343_000; 100]);
+    ckbtc.refresh_fee_percentiles();
+    let retrieve_btc_min_amount = ckbtc.get_minter_info().retrieve_btc_min_amount;
+    assert_eq!(retrieve_btc_min_amount, 200_000);
+}