add tx_refund_amnesty

binarybaron · Einliterflasche · commit c5e0871e932d · 2025-12-01T16:29:16.000+01:00
diff --git a/swap-core/src/bitcoin.rs b/swap-core/src/bitcoin.rs
@@ -6,6 +6,7 @@ mod lock;
 mod punish;
 mod redeem;
 mod refund;
+mod refund_amnesty;
 mod timelocks;
 
 pub use crate::bitcoin::cancel::TxCancel;
@@ -14,6 +15,7 @@ pub use crate::bitcoin::lock::TxLock;
 pub use crate::bitcoin::punish::TxPunish;
 pub use crate::bitcoin::redeem::TxRedeem;
 pub use crate::bitcoin::refund::TxRefund;
+pub use crate::bitcoin::refund_amnesty::TxRefundAmnesty;
 pub use crate::bitcoin::timelocks::{BlockHeight, ExpiredTimelocks};
 pub use crate::bitcoin::timelocks::{CancelTimelock, PunishTimelock};
 pub use ::bitcoin::amount::Amount;
diff --git a/swap-core/src/bitcoin/cancel.rs b/swap-core/src/bitcoin/cancel.rs
@@ -193,6 +193,42 @@ impl TxCancel {
         }
     }
 
+    pub fn build_refund_with_amnesty_transaction(
+        &self,
+        refund_address: &Address,
+        amnesty_descriptor: &Descriptor<::bitcoin::PublicKey>,
+        amnesty_amount: Amount,
+        spending_fee: Amount,
+    ) -> Transaction {
+        let previous_output = self.as_outpoint();
+
+        let tx_in = TxIn {
+            previous_output,
+            script_sig: Default::default(),
+            sequence: Sequence(0xFFFF_FFFF),
+            witness: Default::default(),
+        };
+
+        let refund_amount = self.amount() - amnesty_amount - spending_fee;
+
+        let tx_out_refund = TxOut {
+            value: refund_amount,
+            script_pubkey: refund_address.script_pubkey(),
+        };
+
+        let tx_out_amnesty = TxOut {
+            value: amnesty_amount,
+            script_pubkey: amnesty_descriptor.script_pubkey(),
+        };
+
+        Transaction {
+            version: Version(2),
+            lock_time: PackedLockTime::from_height(0).expect("0 to be below lock time threshold"),
+            input: vec![tx_in],
+            output: vec![tx_out_refund, tx_out_amnesty],
+        }
+    }
+
     pub fn weight() -> Weight {
         Weight::from_wu(596)
     }
diff --git a/swap-core/src/bitcoin/refund.rs b/swap-core/src/bitcoin/refund.rs
@@ -2,8 +2,8 @@
 
 use crate::bitcoin;
 use crate::bitcoin::{
-    verify_sig, Address, Amount, EmptyWitnessStack, NoInputs, NotThreeWitnesses, PublicKey,
-    TooManyInputs, Transaction, TxCancel,
+    build_shared_output_descriptor, verify_sig, Address, Amount, EmptyWitnessStack, NoInputs,
+    NotThreeWitnesses, PublicKey, TooManyInputs, Transaction, TxCancel,
 };
 use ::bitcoin::sighash::SighashCache;
 use ::bitcoin::{secp256k1, ScriptBuf, Weight};
@@ -23,16 +23,32 @@ pub struct TxRefund {
     inner: Transaction,
     digest: Sighash,
     cancel_output_descriptor: Descriptor<::bitcoin::PublicKey>,
+    pub(in crate::bitcoin) amnesty_output_descriptor: Descriptor<::bitcoin::PublicKey>,
     watch_script: ScriptBuf,
 }
 
 impl TxRefund {
-    pub fn new(tx_cancel: &TxCancel, refund_address: &Address, spending_fee: Amount) -> Self {
-        let tx_refund = tx_cancel.build_spend_transaction(refund_address, None, spending_fee);
+    pub fn new(
+        tx_cancel: &TxCancel,
+        refund_address: &Address,
+        A: PublicKey,
+        B: PublicKey,
+        amnesty_amount: Amount,
+        spending_fee: Amount,
+    ) -> Result<Self> {
+        let amnesty_output_descriptor = build_shared_output_descriptor(A.0, B.0)?;
+
+        let tx_refund = tx_cancel.build_refund_with_amnesty_transaction(
+            refund_address,
+            &amnesty_output_descriptor,
+            amnesty_amount,
+            spending_fee,
+        );
 
         let digest = SighashCache::new(&tx_refund)
             .p2wsh_signature_hash(
-                0, // Only one input: cancel transaction
+                // Only one input: cancel transaction
+                0,
                 &tx_cancel
                     .output_descriptor
                     .script_code()
@@ -42,12 +58,13 @@ impl TxRefund {
             )
             .expect("sighash");
 
-        Self {
+        Ok(Self {
             inner: tx_refund,
             digest,
             cancel_output_descriptor: tx_cancel.output_descriptor.clone(),
+            amnesty_output_descriptor,
             watch_script: refund_address.script_pubkey(),
-        }
+        })
     }
 
     pub fn txid(&self) -> Txid {
@@ -58,6 +75,41 @@ impl TxRefund {
         self.digest
     }
 
+    pub fn amnesty_amount(&self) -> Amount {
+        self.inner.output[1].value
+    }
+
+    pub fn amnesty_outpoint(&self) -> ::bitcoin::OutPoint {
+        ::bitcoin::OutPoint::new(self.txid(), 1)
+    }
+
+    pub fn build_amnesty_spend_transaction(
+        &self,
+        refund_address: &Address,
+        spending_fee: Amount,
+    ) -> Transaction {
+        use ::bitcoin::{transaction::Version, locktime::absolute::LockTime as PackedLockTime, Sequence, TxIn, TxOut};
+
+        let tx_in = TxIn {
+            previous_output: self.amnesty_outpoint(),
+            script_sig: Default::default(),
+            sequence: Sequence(0xFFFF_FFFF),
+            witness: Default::default(),
+        };
+
+        let tx_out = TxOut {
+            value: self.amnesty_amount() - spending_fee,
+            script_pubkey: refund_address.script_pubkey(),
+        };
+
+        Transaction {
+            version: Version(2),
+            lock_time: PackedLockTime::from_height(0).expect("0 to be below lock time threshold"),
+            input: vec![tx_in],
+            output: vec![tx_out],
+        }
+    }
+
     pub fn add_signatures(
         self,
         (A, sig_a): (PublicKey, Signature),
@@ -77,6 +129,7 @@ impl TxRefund {
 
             let sig_a = secp256k1::ecdsa::Signature::from_compact(&sig_a.to_bytes())?;
             let sig_b = secp256k1::ecdsa::Signature::from_compact(&sig_b.to_bytes())?;
+            
             // The order in which these are inserted doesn't matter
             satisfier.insert(
                 A,
diff --git a/swap-core/src/bitcoin/refund_amnesty.rs b/swap-core/src/bitcoin/refund_amnesty.rs
@@ -0,0 +1,118 @@
+use crate::bitcoin;
+use crate::bitcoin::{
+    verify_sig, Address, Amount, EmptyWitnessStack, NoInputs, NotThreeWitnesses, PublicKey,
+    TooManyInputs, Transaction, TxRefund,
+};
+use ::bitcoin::sighash::SighashCache;
+use ::bitcoin::{secp256k1, ScriptBuf, Weight};
+use ::bitcoin::{sighash::SegwitV0Sighash as Sighash, EcdsaSighashType, Txid};
+use anyhow::{bail, Context, Result};
+use bdk_wallet::miniscript::Descriptor;
+use bitcoin_wallet::primitives::Watchable;
+use curve25519_dalek::scalar::Scalar;
+use ecdsa_fun::Signature;
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use super::extract_ecdsa_sig;
+
+#[derive(Debug, Clone)]
+pub struct TxRefundAmnesty {
+    inner: Transaction,
+    digest: Sighash,
+    amensty_output_descriptor: Descriptor<::bitcoin::PublicKey>,
+    watch_script: ScriptBuf,
+}
+
+impl TxRefundAmnesty {
+    pub fn new(tx_refund: &TxRefund, refund_address: &Address, spending_fee: Amount) -> Self {
+        let tx_refund_amnesty = tx_refund.build_amnesty_spend_transaction(refund_address, spending_fee);
+
+        let digest = SighashCache::new(&tx_refund_amnesty)
+            .p2wsh_signature_hash(
+                0, // Only one input: amnesty box from tx_refund
+                &tx_refund
+                    .amnesty_output_descriptor
+                    .script_code()
+                    .expect("scriptcode"),
+                tx_refund.amnesty_amount(),
+                EcdsaSighashType::All,
+            )
+            .expect("sighash");
+
+        Self {
+            inner: tx_refund_amnesty,
+            digest,
+            amensty_output_descriptor: tx_refund.amnesty_output_descriptor.clone(),
+            watch_script: refund_address.script_pubkey(),
+        }
+    }
+
+    pub fn txid(&self) -> Txid {
+        self.inner.compute_txid()
+    }
+
+    pub fn digest(&self) -> Sighash {
+        self.digest
+    }
+
+    pub fn add_signatures(
+        self,
+        (A, sig_a): (PublicKey, Signature),
+        (B, sig_b): (PublicKey, Signature),
+    ) -> Result<Transaction> {
+        let satisfier = {
+            let mut satisfier = HashMap::with_capacity(2);
+
+            let A = ::bitcoin::PublicKey {
+                compressed: true,
+                inner: secp256k1::PublicKey::from_slice(&A.0.to_bytes())?,
+            };
+            let B = ::bitcoin::PublicKey {
+                compressed: true,
+                inner: secp256k1::PublicKey::from_slice(&B.0.to_bytes())?,
+            };
+
+            let sig_a = secp256k1::ecdsa::Signature::from_compact(&sig_a.to_bytes())?;
+            let sig_b = secp256k1::ecdsa::Signature::from_compact(&sig_b.to_bytes())?;
+            
+            // The order in which these are inserted doesn't matter
+            satisfier.insert(
+                A,
+                ::bitcoin::ecdsa::Signature {
+                    signature: sig_a,
+                    sighash_type: EcdsaSighashType::All,
+                },
+            );
+            satisfier.insert(
+                B,
+                ::bitcoin::ecdsa::Signature {
+                    signature: sig_b,
+                    sighash_type: EcdsaSighashType::All,
+                },
+            );
+
+            satisfier
+        };
+
+        let mut tx_refund = self.inner;
+        self.amensty_output_descriptor
+            .satisfy(&mut tx_refund.input[0], satisfier)?;
+
+        Ok(tx_refund)
+    }
+
+    pub fn weight() -> Weight {
+        Weight::from_wu(548)
+    }
+}
+
+impl Watchable for TxRefundAmnesty {
+    fn id(&self) -> Txid {
+        self.txid()
+    }
+
+    fn script(&self) -> ScriptBuf {
+        self.watch_script.clone()
+    }
+}
