feat(via_btc_sender): harden spendability, fee floors, and anti-dust policy

core/lib/config/src/configs/via_btc_sender.rs

@@ -35,6 +35,27 @@ pub struct ViaBtcSenderConfig {
 
     /// The required time (seconds) to wait before create a proof inscription.
     pub block_time_to_proof: Option<u32>,
+
+    /// Hard floor for taproot inscription output to avoid dust / borderline outputs.
+    pub min_inscription_output_sats: Option<u64>,
+
+    /// Hard floor for change output to keep spendable UTXOs healthy.
+    pub min_change_output_sats: Option<u64>,
+
+    /// Minimum fee-rate for non-chained transactions (sat/vB).
+    pub min_feerate_sat_vb: Option<u64>,
+
+    /// Minimum fee-rate when pending inscriptions exist in context (sat/vB).
+    pub min_chained_feerate_sat_vb: Option<u64>,
+
+    /// Maximum fee-rate safety cap (sat/vB).
+    pub max_feerate_sat_vb: Option<u64>,
+
+    /// Max number of pending inscriptions in context before pausing new sends.
+    pub max_pending_chain_depth: Option<u32>,
+
+    /// Do not send new inscriptions when trusted (confirmed) balance goes below this threshold.
+    pub min_spendable_balance_sats: Option<u64>,
 }
 
 impl ViaBtcSenderConfig {
@@ -60,6 +81,34 @@ impl ViaBtcSenderConfig {
     pub fn stuck_inscription_block_number(&self) -> u32 {
         self.stuck_inscription_block_number.unwrap_or(6)
     }
+
+    pub fn min_inscription_output_sats(&self) -> u64 {
+        self.min_inscription_output_sats.unwrap_or(600)
+    }
+
+    pub fn min_change_output_sats(&self) -> u64 {
+        self.min_change_output_sats.unwrap_or(1_000)
+    }
+
+    pub fn min_feerate_sat_vb(&self) -> u64 {
+        self.min_feerate_sat_vb.unwrap_or(8)
+    }
+
+    pub fn min_chained_feerate_sat_vb(&self) -> u64 {
+        self.min_chained_feerate_sat_vb.unwrap_or(20)
+    }
+
+    pub fn max_feerate_sat_vb(&self) -> u64 {
+        self.max_feerate_sat_vb.unwrap_or(80)
+    }
+
+    pub fn max_pending_chain_depth(&self) -> u32 {
+        self.max_pending_chain_depth.unwrap_or(3)
+    }
+
+    pub fn min_spendable_balance_sats(&self) -> u64 {
+        self.min_spendable_balance_sats.unwrap_or(2_000)
+    }
 }
 
 impl ViaBtcSenderConfig {
@@ -76,6 +125,13 @@ impl ViaBtcSenderConfig {
             block_time_to_commit: None,
             block_time_to_proof: None,
             stuck_inscription_block_number: None,
+            min_inscription_output_sats: None,
+            min_change_output_sats: None,
+            min_feerate_sat_vb: None,
+            min_chained_feerate_sat_vb: None,
+            max_feerate_sat_vb: None,
+            max_pending_chain_depth: None,
+            min_spendable_balance_sats: None,
         }
     }
 }

core/lib/via_btc_client/src/inscriber/mod.rs

@@ -64,12 +64,39 @@ const BROADCAST_RETRY_COUNT: u32 = 3;
 // https://bitcoin.stackexchange.com/questions/10986/what-is-meant-by-bitcoin-dust
 // https://bitcointalk.org/index.php?topic=5453107.msg62262343#msg62262343
 const P2TR_DUST_LIMIT: Amount = Amount::from_sat(330);
+const DEFAULT_MIN_INSCRIPTION_OUTPUT_SATS: u64 = 600;
+const DEFAULT_MIN_CHANGE_OUTPUT_SATS: u64 = 1_000;
+const DEFAULT_MIN_FEERATE_SAT_VB: u64 = 8;
+const DEFAULT_MIN_CHAINED_FEERATE_SAT_VB: u64 = 20;
+const DEFAULT_MAX_FEERATE_SAT_VB: u64 = 80;
+
+#[derive(Debug, Clone)]
+pub struct InscriberPolicy {
+    pub min_inscription_output_sats: u64,
+    pub min_change_output_sats: u64,
+    pub min_feerate_sat_vb: u64,
+    pub min_chained_feerate_sat_vb: u64,
+    pub max_feerate_sat_vb: u64,
+}
+
+impl Default for InscriberPolicy {
+    fn default() -> Self {
+        Self {
+            min_inscription_output_sats: DEFAULT_MIN_INSCRIPTION_OUTPUT_SATS,
+            min_change_output_sats: DEFAULT_MIN_CHANGE_OUTPUT_SATS,
+            min_feerate_sat_vb: DEFAULT_MIN_FEERATE_SAT_VB,
+            min_chained_feerate_sat_vb: DEFAULT_MIN_CHAINED_FEERATE_SAT_VB,
+            max_feerate_sat_vb: DEFAULT_MAX_FEERATE_SAT_VB,
+        }
+    }
+}
 
 #[derive(Debug)]
 pub struct Inscriber {
     client: Arc<dyn BitcoinOps>,
     signer: Arc<dyn BitcoinSigner>,
     context: InscriberContext,
+    policy: InscriberPolicy,
 }
 
 impl Inscriber {
@@ -90,6 +117,7 @@ impl Inscriber {
             client,
             signer,
             context,
+            policy: InscriberPolicy::default(),
         })
     }
 
@@ -114,6 +142,25 @@ impl Inscriber {
         Ok(balance)
     }
 
+    #[instrument(skip(self), target = "bitcoin_inscriber")]
+    pub async fn get_trusted_balance(&self) -> Result<u128> {
+        let address_ref = &self.signer.get_p2wpkh_address()?;
+        Ok(self.client.get_balance(address_ref).await?)
+    }
+
+    pub fn with_policy(mut self, policy: InscriberPolicy) -> Self {
+        self.policy = policy;
+        self
+    }
+
+    pub fn set_policy(&mut self, policy: InscriberPolicy) {
+        self.policy = policy;
+    }
+
+    pub fn pending_chain_depth(&self) -> usize {
+        self.context.fifo_queue.len()
+    }
+
     #[instrument(skip(self, input), target = "bitcoin_inscriber")]
     pub async fn prepare_inscribe(
         &mut self,
@@ -355,8 +402,15 @@ impl Inscriber {
         inscription_pubkey: ScriptBuf,
     ) -> Result<CommitTxOutputRes> {
         debug!("Preparing commit transaction output");
+        let min_inscription_output = Amount::from_sat(
+            std::cmp::max(
+                self.policy.min_inscription_output_sats,
+                P2TR_DUST_LIMIT.to_sat(),
+            ),
+        );
+
         let inscription_commitment_output = TxOut {
-            value: P2TR_DUST_LIMIT,
+            value: min_inscription_output,
             script_pubkey: inscription_pubkey,
         };
 
@@ -373,17 +427,29 @@ impl Inscriber {
         let fee_amount_before_decrease = fee_amount;
         fee_amount -= (fee_amount * FEE_RATE_DECREASE_COMMIT_TX) / 100;
 
+        let required_amount = fee_amount + min_inscription_output;
+
         let commit_tx_change_output_value = tx_input_data
             .unlocked_value
-            .checked_sub(fee_amount + P2TR_DUST_LIMIT)
+            .checked_sub(required_amount)
             .ok_or_else(|| {
                 anyhow::anyhow!(
                     "Required Amount: {:?}, Spendable Amount: {:?} ",
-                    fee_amount + P2TR_DUST_LIMIT,
+                    required_amount,
                     tx_input_data.unlocked_value
                 )
             })?;
 
+        if commit_tx_change_output_value < Amount::from_sat(self.policy.min_change_output_sats) {
+            anyhow::bail!(
+                "Required Amount: {:?}, Spendable Amount: {:?}. change output {:?} is below minimum {:?}",
+                required_amount + Amount::from_sat(self.policy.min_change_output_sats),
+                tx_input_data.unlocked_value,
+                commit_tx_change_output_value,
+                Amount::from_sat(self.policy.min_change_output_sats)
+            );
+        }
+
         let commit_tx_change_output = TxOut {
             value: commit_tx_change_output_value,
             script_pubkey: self.signer.get_p2wpkh_script_pubkey().clone(),
@@ -405,8 +471,26 @@ impl Inscriber {
     async fn get_fee_rate(&self) -> Result<u64> {
         debug!("Getting fee rate");
         let res = self.client.get_fee_rate(FEE_RATE_CONF_TARGET).await?;
-        debug!("Fee rate obtained: {}", res);
-        Ok(std::cmp::max(res, 1))
+        let min_floor = if self.context.fifo_queue.is_empty() {
+            self.policy.min_feerate_sat_vb
+        } else {
+            self.policy.min_chained_feerate_sat_vb
+        };
+
+        let max_cap = self.policy.max_feerate_sat_vb;
+        let effective = if max_cap < min_floor {
+            warn!(
+                "Inconsistent fee policy: max_feerate_sat_vb ({}) < min_floor ({}); ignoring max cap",
+                max_cap,
+                min_floor
+            );
+            std::cmp::max(res, min_floor)
+        } else {
+            std::cmp::min(std::cmp::max(res, min_floor), max_cap)
+        };
+
+        debug!("Fee rate obtained: {}, effective: {}", res, effective);
+        Ok(std::cmp::max(effective, 1))
     }
 
     #[instrument(skip(self, input, output), target = "bitcoin_inscriber")]
@@ -609,12 +693,22 @@ impl Inscriber {
             .checked_sub(fee_amount + recipient_amount)
             .ok_or_else(|| {
                 anyhow::anyhow!(
-                    "Required Amount:{:?} Spendable Amount: {:?} ",
+                    "Required Amount: {:?} Spendable Amount: {:?} ",
                     fee_amount + recipient_amount,
                     tx_input_data.unlock_value
                 )
             })?;
 
+        if reveal_change_amount < Amount::from_sat(self.policy.min_change_output_sats) {
+            anyhow::bail!(
+                "Required Amount: {:?} Spendable Amount: {:?}. reveal change output {:?} is below minimum {:?}",
+                fee_amount + recipient_amount + Amount::from_sat(self.policy.min_change_output_sats),
+                tx_input_data.unlock_value,
+                reveal_change_amount,
+                Amount::from_sat(self.policy.min_change_output_sats)
+            );
+        }
+
         // Change output goes back to the inscriber
         let reveal_tx_change_output = TxOut {
             value: reveal_change_amount,
@@ -849,8 +943,8 @@ mod tests {
 
     use super::*;
     use crate::types::{
-        BitcoinClientResult, BitcoinNetwork, BitcoinSignerResult, InscriptionMessage,
-        L1BatchDAReferenceInput,
+        BitcoinClientResult, BitcoinNetwork, BitcoinSignerResult, CommitTxInput, FeePayerCtx,
+        InscriberOutput, InscriptionMessage, InscriptionRequest, L1BatchDAReferenceInput,
     };
 
     mock! {
@@ -968,6 +1062,21 @@ mod tests {
             client: Arc::new(client),
             signer: Arc::new(signer),
             context,
+            policy: InscriberPolicy::default(),
+        }
+    }
+
+    fn get_mock_inscriber_for_fee_rate_tests() -> Inscriber {
+        let mut client = MockBitcoinOps::new();
+        let signer = MockBitcoinSigner::new();
+
+        client.expect_get_fee_rate().returning(|_| Ok(1));
+
+        Inscriber {
+            client: Arc::new(client),
+            signer: Arc::new(signer),
+            context: InscriberContext::default(),
+            policy: InscriberPolicy::default(),
         }
     }
 
@@ -990,4 +1099,61 @@ mod tests {
         assert_ne!(res.final_commit_tx.txid, Txid::all_zeros());
         assert_ne!(res.final_reveal_tx.txid, Txid::all_zeros());
     }
+
+    #[tokio::test]
+    async fn test_get_fee_rate_applies_floor_when_context_empty() {
+        let mut inscriber = get_mock_inscriber_for_fee_rate_tests();
+        inscriber.set_policy(InscriberPolicy {
+            min_inscription_output_sats: 600,
+            min_change_output_sats: 1_000,
+            min_feerate_sat_vb: 12,
+            min_chained_feerate_sat_vb: 20,
+            max_feerate_sat_vb: 50,
+        });
+
+        let fee_rate = inscriber.get_fee_rate().await.unwrap();
+        assert_eq!(fee_rate, 12);
+    }
+
+    #[tokio::test]
+    async fn test_get_fee_rate_handles_inconsistent_cap_when_context_non_empty() {
+        let mut inscriber = get_mock_inscriber_for_fee_rate_tests();
+        inscriber.context.fifo_queue.push_back(InscriptionRequest {
+            message: InscriptionMessage::L1BatchDAReference(L1BatchDAReferenceInput {
+                l1_batch_hash: zksync_basic_types::H256([0; 32]),
+                l1_batch_index: zksync_basic_types::L1BatchNumber(0_u32),
+                da_identifier: "da_identifier_celestia".to_string(),
+                blob_id: "batch_temp_blob_id".to_string(),
+                prev_l1_batch_hash: zksync_basic_types::H256([0; 32]),
+            }),
+            inscriber_output: InscriberOutput {
+                commit_txid: Txid::all_zeros(),
+                commit_raw_tx: String::new(),
+                commit_tx_fee_rate: 0,
+                reveal_txid: Txid::all_zeros(),
+                reveal_raw_tx: String::new(),
+                reveal_tx_fee_rate: 0,
+                is_broadcasted: false,
+            },
+            fee_payer_ctx: FeePayerCtx {
+                fee_payer_utxo_txid: Txid::all_zeros(),
+                fee_payer_utxo_vout: 0,
+                fee_payer_utxo_value: Amount::from_sat(0),
+            },
+            commit_tx_input: CommitTxInput {
+                spent_utxo: vec![TxIn::default()],
+            },
+        });
+
+        inscriber.set_policy(InscriberPolicy {
+            min_inscription_output_sats: 600,
+            min_change_output_sats: 1_000,
+            min_feerate_sat_vb: 8,
+            min_chained_feerate_sat_vb: 20,
+            max_feerate_sat_vb: 10,
+        });
+
+        let fee_rate = inscriber.get_fee_rate().await.unwrap();
+        assert_eq!(fee_rate, 20);
+    }
 }

core/node/node_framework/src/implementations/layers/via_btc_sender/aggregator.rs

@@ -1,11 +1,15 @@
+use anyhow::Context;
 use via_btc_client::inscriber::Inscriber;
 use via_btc_sender::btc_inscription_aggregator::ViaBtcInscriptionAggregator;
 use zksync_config::{configs::via_wallets::ViaWallet, ViaBtcSenderConfig};
 
 use crate::{
-    implementations::resources::{
-        pools::{MasterPool, PoolResource},
-        via_btc_client::BtcClientResource,
+    implementations::{
+        layers::via_btc_sender::policy::build_inscriber_policy,
+        resources::{
+            pools::{MasterPool, PoolResource},
+            via_btc_client::BtcClientResource,
+        },
     },
     service::StopReceiver,
     task::{Task, TaskId},
@@ -66,9 +70,12 @@ impl WiringLayer for ViaBtcInscriptionAggregatorLayer {
         let master_pool = input.master_pool.get().await.unwrap();
         let client = input.btc_client_resource.btc_sender.unwrap();
 
+        let inscriber_policy = build_inscriber_policy(&self.config);
+
         let inscriber = Inscriber::new(client, &self.wallet.private_key, None)
             .await
-            .unwrap();
+            .with_context(|| "Error init inscriber")?
+            .with_policy(inscriber_policy);
 
         let via_btc_inscription_aggregator =
             ViaBtcInscriptionAggregator::new(inscriber, master_pool, self.config).await?;