Lucas Soriano del Pino
3 years ago
4 changed files with 499 additions and 459 deletions
@ -0,0 +1,15 @@ |
|||||
|
use bdk::bitcoin::hashes::Hash; |
||||
|
use bdk::bitcoin::SigHash; |
||||
|
|
||||
|
pub(super) trait SigHashExt { |
||||
|
fn to_message(self) -> secp256k1_zkp::Message; |
||||
|
} |
||||
|
|
||||
|
impl SigHashExt for SigHash { |
||||
|
fn to_message(self) -> secp256k1_zkp::Message { |
||||
|
use secp256k1_zkp::bitcoin_hashes::Hash; |
||||
|
let hash = secp256k1_zkp::bitcoin_hashes::sha256d::Hash::from_inner(*self.as_inner()); |
||||
|
|
||||
|
hash.into() |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,26 @@ |
|||||
|
use anyhow::{Context, Result}; |
||||
|
use bdk::bitcoin::{OutPoint, Script, Transaction}; |
||||
|
|
||||
|
pub trait TransactionExt { |
||||
|
fn get_virtual_size(&self) -> f64; |
||||
|
fn outpoint(&self, script_pubkey: &Script) -> Result<OutPoint>; |
||||
|
} |
||||
|
|
||||
|
impl TransactionExt for Transaction { |
||||
|
fn get_virtual_size(&self) -> f64 { |
||||
|
self.get_weight() as f64 / 4.0 |
||||
|
} |
||||
|
|
||||
|
fn outpoint(&self, script_pubkey: &Script) -> Result<OutPoint> { |
||||
|
let vout = self |
||||
|
.output |
||||
|
.iter() |
||||
|
.position(|out| &out.script_pubkey == script_pubkey) |
||||
|
.context("script pubkey not found in tx")?; |
||||
|
|
||||
|
Ok(OutPoint { |
||||
|
txid: self.txid(), |
||||
|
vout: vout as u32, |
||||
|
}) |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,441 @@ |
|||||
|
use crate::protocol::sighash_ext::SigHashExt; |
||||
|
use crate::protocol::transaction_ext::TransactionExt; |
||||
|
use crate::protocol::{ |
||||
|
commit_descriptor, compute_adaptor_point, lock_descriptor, Payout, DUMMY_2OF2_MULTISIG, |
||||
|
}; |
||||
|
|
||||
|
use anyhow::{Context, Result}; |
||||
|
use bdk::bitcoin::util::bip143::SigHashCache; |
||||
|
use bdk::bitcoin::util::psbt::{Global, PartiallySignedTransaction}; |
||||
|
use bdk::bitcoin::{ |
||||
|
Address, Amount, OutPoint, PublicKey, SigHash, SigHashType, Transaction, TxIn, TxOut, |
||||
|
}; |
||||
|
use bdk::descriptor::Descriptor; |
||||
|
use bdk::miniscript::DescriptorTrait; |
||||
|
use itertools::Itertools; |
||||
|
use secp256k1_zkp::{self, schnorrsig, EcdsaAdaptorSignature, SecretKey, Signature, SECP256K1}; |
||||
|
use std::collections::HashMap; |
||||
|
use std::iter::FromIterator; |
||||
|
|
||||
|
/// In satoshi per vbyte.
|
||||
|
const SATS_PER_VBYTE: f64 = 1.0; |
||||
|
|
||||
|
pub(super) fn lock_transaction( |
||||
|
maker_psbt: PartiallySignedTransaction, |
||||
|
taker_psbt: PartiallySignedTransaction, |
||||
|
maker_pk: PublicKey, |
||||
|
taker_pk: PublicKey, |
||||
|
amount: Amount, |
||||
|
) -> PartiallySignedTransaction { |
||||
|
let lock_descriptor = lock_descriptor(maker_pk, taker_pk); |
||||
|
|
||||
|
let maker_change = maker_psbt |
||||
|
.global |
||||
|
.unsigned_tx |
||||
|
.output |
||||
|
.into_iter() |
||||
|
.filter(|out| { |
||||
|
out.script_pubkey != DUMMY_2OF2_MULTISIG.parse().expect("To be a valid script") |
||||
|
}) |
||||
|
.collect::<Vec<_>>(); |
||||
|
|
||||
|
let taker_change = taker_psbt |
||||
|
.global |
||||
|
.unsigned_tx |
||||
|
.output |
||||
|
.into_iter() |
||||
|
.filter(|out| { |
||||
|
out.script_pubkey != DUMMY_2OF2_MULTISIG.parse().expect("To be a valid script") |
||||
|
}) |
||||
|
.collect::<Vec<_>>(); |
||||
|
|
||||
|
let lock_output = TxOut { |
||||
|
value: amount.as_sat(), |
||||
|
script_pubkey: lock_descriptor.script_pubkey(), |
||||
|
}; |
||||
|
|
||||
|
let input = vec![ |
||||
|
maker_psbt.global.unsigned_tx.input, |
||||
|
taker_psbt.global.unsigned_tx.input, |
||||
|
] |
||||
|
.concat(); |
||||
|
|
||||
|
let output = std::iter::once(lock_output) |
||||
|
.chain(maker_change) |
||||
|
.chain(taker_change) |
||||
|
.collect(); |
||||
|
|
||||
|
let lock_tx = Transaction { |
||||
|
version: 2, |
||||
|
lock_time: 0, |
||||
|
input, |
||||
|
output, |
||||
|
}; |
||||
|
|
||||
|
PartiallySignedTransaction { |
||||
|
global: Global::from_unsigned_tx(lock_tx).expect("to be unsigned"), |
||||
|
inputs: vec![maker_psbt.inputs, taker_psbt.inputs].concat(), |
||||
|
outputs: vec![maker_psbt.outputs, taker_psbt.outputs].concat(), |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
#[derive(Debug, Clone)] |
||||
|
pub(super) struct CommitTransaction { |
||||
|
inner: Transaction, |
||||
|
descriptor: Descriptor<PublicKey>, |
||||
|
amount: Amount, |
||||
|
sighash: SigHash, |
||||
|
lock_descriptor: Descriptor<PublicKey>, |
||||
|
fee: u64, |
||||
|
} |
||||
|
|
||||
|
impl CommitTransaction { |
||||
|
/// Expected size of signed transaction in virtual bytes, plus a
|
||||
|
/// buffer to account for different signature lengths.
|
||||
|
const SIGNED_VBYTES: f64 = 148.5 + (3.0 * 2.0) / 4.0; |
||||
|
|
||||
|
pub(super) fn new( |
||||
|
lock_tx: &Transaction, |
||||
|
(maker_pk, maker_rev_pk, maker_publish_pk): (PublicKey, PublicKey, PublicKey), |
||||
|
(taker_pk, taker_rev_pk, taker_publish_pk): (PublicKey, PublicKey, PublicKey), |
||||
|
) -> Result<Self> { |
||||
|
let lock_descriptor = lock_descriptor(maker_pk, taker_pk); |
||||
|
let (lock_outpoint, lock_amount) = { |
||||
|
let outpoint = lock_tx |
||||
|
.outpoint(&lock_descriptor.script_pubkey()) |
||||
|
.context("lock script not found in lock tx")?; |
||||
|
let amount = lock_tx.output[outpoint.vout as usize].value; |
||||
|
|
||||
|
(outpoint, amount) |
||||
|
}; |
||||
|
|
||||
|
let lock_input = TxIn { |
||||
|
previous_output: lock_outpoint, |
||||
|
..Default::default() |
||||
|
}; |
||||
|
|
||||
|
let descriptor = commit_descriptor( |
||||
|
(maker_pk, maker_rev_pk, maker_publish_pk), |
||||
|
(taker_pk, taker_rev_pk, taker_publish_pk), |
||||
|
); |
||||
|
|
||||
|
let output = TxOut { |
||||
|
value: lock_amount, |
||||
|
script_pubkey: descriptor.script_pubkey(), |
||||
|
}; |
||||
|
|
||||
|
let mut inner = Transaction { |
||||
|
version: 2, |
||||
|
lock_time: 0, |
||||
|
input: vec![lock_input], |
||||
|
output: vec![output], |
||||
|
}; |
||||
|
let fee = (Self::SIGNED_VBYTES * SATS_PER_VBYTE as f64) as u64; |
||||
|
|
||||
|
let commit_tx_amount = lock_amount - fee as u64; |
||||
|
inner.output[0].value = commit_tx_amount; |
||||
|
|
||||
|
let sighash = SigHashCache::new(&inner).signature_hash( |
||||
|
0, |
||||
|
&lock_descriptor.script_code(), |
||||
|
lock_amount, |
||||
|
SigHashType::All, |
||||
|
); |
||||
|
|
||||
|
Ok(Self { |
||||
|
inner, |
||||
|
descriptor, |
||||
|
lock_descriptor, |
||||
|
amount: Amount::from_sat(commit_tx_amount), |
||||
|
sighash, |
||||
|
fee, |
||||
|
}) |
||||
|
} |
||||
|
|
||||
|
pub(super) fn encsign( |
||||
|
&self, |
||||
|
sk: SecretKey, |
||||
|
publish_them_pk: &PublicKey, |
||||
|
) -> EcdsaAdaptorSignature { |
||||
|
EcdsaAdaptorSignature::encrypt( |
||||
|
SECP256K1, |
||||
|
&self.sighash.to_message(), |
||||
|
&sk, |
||||
|
&publish_them_pk.key, |
||||
|
) |
||||
|
} |
||||
|
|
||||
|
pub(super) fn into_inner(self) -> Transaction { |
||||
|
self.inner |
||||
|
} |
||||
|
|
||||
|
fn outpoint(&self) -> OutPoint { |
||||
|
self.inner |
||||
|
.outpoint(&self.descriptor.script_pubkey()) |
||||
|
.expect("to find commit output in commit tx") |
||||
|
} |
||||
|
|
||||
|
fn amount(&self) -> Amount { |
||||
|
self.amount |
||||
|
} |
||||
|
|
||||
|
fn descriptor(&self) -> Descriptor<PublicKey> { |
||||
|
self.descriptor.clone() |
||||
|
} |
||||
|
|
||||
|
fn fee(&self) -> u64 { |
||||
|
self.fee |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
#[derive(Debug, Clone)] |
||||
|
pub(super) struct ContractExecutionTransaction { |
||||
|
inner: Transaction, |
||||
|
msg_nonce_pairs: Vec<(Vec<u8>, schnorrsig::PublicKey)>, |
||||
|
sighash: SigHash, |
||||
|
commit_descriptor: Descriptor<PublicKey>, |
||||
|
} |
||||
|
|
||||
|
impl ContractExecutionTransaction { |
||||
|
/// Expected size of signed transaction in virtual bytes, plus a
|
||||
|
/// buffer to account for different signature lengths.
|
||||
|
const SIGNED_VBYTES: f64 = 206.5 + (3.0 * 2.0) / 4.0; |
||||
|
|
||||
|
pub(super) fn new( |
||||
|
commit_tx: &CommitTransaction, |
||||
|
payout: Payout, |
||||
|
maker_address: &Address, |
||||
|
taker_address: &Address, |
||||
|
relative_timelock_in_blocks: u32, |
||||
|
) -> Result<Self> { |
||||
|
let msg_nonce_pairs = payout.msg_nonce_pairs.clone(); |
||||
|
let commit_input = TxIn { |
||||
|
previous_output: commit_tx.outpoint(), |
||||
|
sequence: relative_timelock_in_blocks, |
||||
|
..Default::default() |
||||
|
}; |
||||
|
|
||||
|
let mut fee = Self::SIGNED_VBYTES * SATS_PER_VBYTE; |
||||
|
fee += commit_tx.fee() as f64; |
||||
|
let output = payout |
||||
|
.with_updated_fee( |
||||
|
Amount::from_sat(fee as u64), |
||||
|
maker_address.script_pubkey().dust_value(), |
||||
|
taker_address.script_pubkey().dust_value(), |
||||
|
)? |
||||
|
.into_txouts(maker_address, taker_address); |
||||
|
|
||||
|
let tx = Transaction { |
||||
|
version: 2, |
||||
|
lock_time: 0, |
||||
|
input: vec![commit_input], |
||||
|
output, |
||||
|
}; |
||||
|
|
||||
|
let sighash = SigHashCache::new(&tx).signature_hash( |
||||
|
0, |
||||
|
&commit_tx.descriptor.script_code(), |
||||
|
commit_tx.amount.as_sat(), |
||||
|
SigHashType::All, |
||||
|
); |
||||
|
|
||||
|
Ok(Self { |
||||
|
inner: tx, |
||||
|
msg_nonce_pairs, |
||||
|
sighash, |
||||
|
commit_descriptor: commit_tx.descriptor(), |
||||
|
}) |
||||
|
} |
||||
|
|
||||
|
pub(super) fn encsign( |
||||
|
&self, |
||||
|
sk: SecretKey, |
||||
|
oracle_pk: &schnorrsig::PublicKey, |
||||
|
) -> Result<EcdsaAdaptorSignature> { |
||||
|
let adaptor_point = compute_adaptor_point(oracle_pk, &self.msg_nonce_pairs)?; |
||||
|
|
||||
|
Ok(EcdsaAdaptorSignature::encrypt( |
||||
|
SECP256K1, |
||||
|
&self.sighash.to_message(), |
||||
|
&sk, |
||||
|
&adaptor_point, |
||||
|
)) |
||||
|
} |
||||
|
|
||||
|
pub(super) fn into_inner(self) -> Transaction { |
||||
|
self.inner |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
#[derive(Debug, Clone)] |
||||
|
pub(super) struct RefundTransaction { |
||||
|
inner: Transaction, |
||||
|
sighash: SigHash, |
||||
|
commit_output_descriptor: Descriptor<PublicKey>, |
||||
|
} |
||||
|
|
||||
|
impl RefundTransaction { |
||||
|
/// Expected size of signed transaction in virtual bytes, plus a
|
||||
|
/// buffer to account for different signature lengths.
|
||||
|
const SIGNED_VBYTES: f64 = 206.5 + (3.0 * 2.0) / 4.0; |
||||
|
|
||||
|
pub(super) fn new( |
||||
|
commit_tx: &CommitTransaction, |
||||
|
relative_locktime_in_blocks: u32, |
||||
|
maker_address: &Address, |
||||
|
taker_address: &Address, |
||||
|
maker_amount: Amount, |
||||
|
taker_amount: Amount, |
||||
|
) -> Self { |
||||
|
let commit_input = TxIn { |
||||
|
previous_output: commit_tx.outpoint(), |
||||
|
sequence: relative_locktime_in_blocks, |
||||
|
..Default::default() |
||||
|
}; |
||||
|
|
||||
|
let maker_output = TxOut { |
||||
|
value: maker_amount.as_sat(), |
||||
|
script_pubkey: maker_address.script_pubkey(), |
||||
|
}; |
||||
|
|
||||
|
let taker_output = TxOut { |
||||
|
value: taker_amount.as_sat(), |
||||
|
script_pubkey: taker_address.script_pubkey(), |
||||
|
}; |
||||
|
|
||||
|
let mut tx = Transaction { |
||||
|
version: 2, |
||||
|
lock_time: 0, |
||||
|
input: vec![commit_input], |
||||
|
output: vec![maker_output, taker_output], |
||||
|
}; |
||||
|
|
||||
|
let mut fee = Self::SIGNED_VBYTES * SATS_PER_VBYTE; |
||||
|
fee += commit_tx.fee() as f64; |
||||
|
tx.output[0].value -= (fee / 2.0) as u64; |
||||
|
tx.output[1].value -= (fee / 2.0) as u64; |
||||
|
|
||||
|
let commit_output_descriptor = commit_tx.descriptor(); |
||||
|
|
||||
|
let sighash = SigHashCache::new(&tx).signature_hash( |
||||
|
0, |
||||
|
&commit_tx.descriptor().script_code(), |
||||
|
commit_tx.amount().as_sat(), |
||||
|
SigHashType::All, |
||||
|
); |
||||
|
|
||||
|
Self { |
||||
|
inner: tx, |
||||
|
sighash, |
||||
|
commit_output_descriptor, |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
pub(super) fn sighash(&self) -> SigHash { |
||||
|
self.sighash |
||||
|
} |
||||
|
|
||||
|
pub(super) fn into_inner(self) -> Transaction { |
||||
|
self.inner |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
pub fn punish_transaction( |
||||
|
commit_descriptor: &Descriptor<PublicKey>, |
||||
|
address: &Address, |
||||
|
encsig: EcdsaAdaptorSignature, |
||||
|
sk: SecretKey, |
||||
|
revocation_them_sk: SecretKey, |
||||
|
pub_them_pk: PublicKey, |
||||
|
revoked_commit_tx: &Transaction, |
||||
|
) -> Result<Transaction> { |
||||
|
/// Expected size of signed transaction in virtual bytes, plus a
|
||||
|
/// buffer to account for different signature lengths.
|
||||
|
const SIGNED_VBYTES: f64 = 219.5 + (3.0 * 3.0) / 4.0; |
||||
|
|
||||
|
let input = revoked_commit_tx |
||||
|
.input |
||||
|
.clone() |
||||
|
.into_iter() |
||||
|
.exactly_one() |
||||
|
.context("commit transaction inputs != 1")?; |
||||
|
|
||||
|
let publish_them_sk = input |
||||
|
.witness |
||||
|
.iter() |
||||
|
.filter_map(|elem| { |
||||
|
let elem = elem.as_slice(); |
||||
|
Signature::from_der(&elem[..elem.len() - 1]).ok() |
||||
|
}) |
||||
|
.find_map(|sig| encsig.recover(SECP256K1, &sig, &pub_them_pk.key).ok()) |
||||
|
.context("could not recover publish sk from commit tx")?; |
||||
|
|
||||
|
let commit_outpoint = revoked_commit_tx |
||||
|
.outpoint(&commit_descriptor.script_pubkey()) |
||||
|
.expect("to find commit output in commit tx"); |
||||
|
let commit_amount = revoked_commit_tx.output[commit_outpoint.vout as usize].value; |
||||
|
|
||||
|
let mut punish_tx = { |
||||
|
let output = TxOut { |
||||
|
value: commit_amount, |
||||
|
script_pubkey: address.script_pubkey(), |
||||
|
}; |
||||
|
let mut tx = Transaction { |
||||
|
version: 2, |
||||
|
lock_time: 0, |
||||
|
input: vec![TxIn { |
||||
|
previous_output: commit_outpoint, |
||||
|
..Default::default() |
||||
|
}], |
||||
|
output: vec![output], |
||||
|
}; |
||||
|
|
||||
|
let fee = SIGNED_VBYTES * SATS_PER_VBYTE; |
||||
|
tx.output[0].value = commit_amount - fee as u64; |
||||
|
|
||||
|
tx |
||||
|
}; |
||||
|
|
||||
|
let sighash = SigHashCache::new(&punish_tx).signature_hash( |
||||
|
0, |
||||
|
&commit_descriptor.script_code(), |
||||
|
commit_amount, |
||||
|
SigHashType::All, |
||||
|
); |
||||
|
|
||||
|
let satisfier = { |
||||
|
let pk = { |
||||
|
let key = secp256k1_zkp::PublicKey::from_secret_key(SECP256K1, &sk); |
||||
|
PublicKey { |
||||
|
compressed: true, |
||||
|
key, |
||||
|
} |
||||
|
}; |
||||
|
let pk_hash = pk.pubkey_hash().as_hash(); |
||||
|
let sig_sk = SECP256K1.sign(&sighash.to_message(), &sk); |
||||
|
|
||||
|
let pub_them_pk_hash = pub_them_pk.pubkey_hash().as_hash(); |
||||
|
let sig_pub_them = SECP256K1.sign(&sighash.to_message(), &publish_them_sk); |
||||
|
|
||||
|
let rev_them_pk = { |
||||
|
let key = secp256k1_zkp::PublicKey::from_secret_key(SECP256K1, &revocation_them_sk); |
||||
|
PublicKey { |
||||
|
compressed: true, |
||||
|
key, |
||||
|
} |
||||
|
}; |
||||
|
let rev_them_pk_hash = rev_them_pk.pubkey_hash().as_hash(); |
||||
|
let sig_rev_them = SECP256K1.sign(&sighash.to_message(), &revocation_them_sk); |
||||
|
|
||||
|
let sighash_all = SigHashType::All; |
||||
|
HashMap::from_iter(vec![ |
||||
|
(pk_hash, (pk, (sig_sk, sighash_all))), |
||||
|
(pub_them_pk_hash, (pub_them_pk, (sig_pub_them, sighash_all))), |
||||
|
(rev_them_pk_hash, (rev_them_pk, (sig_rev_them, sighash_all))), |
||||
|
]) |
||||
|
}; |
||||
|
|
||||
|
commit_descriptor.satisfy(&mut punish_tx.input[0], satisfier)?; |
||||
|
|
||||
|
Ok(punish_tx) |
||||
|
} |
||||
Loading…
Reference in new issue