Git-Mirrors/xmr-btc-swap
1
0
Fork 0
mirror of https://github.com/comit-network/xmr-btc-swap.git synced 2024-06-26 06:32:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

Upgrade rust-bitcoin to 0.25

Browse Source
This commit is contained in:
Franck Royer 2020-12-03 17:28:23 +11:00
parent fa6b696c45
commit 624716d8a7
No known key found for this signature in database
GPG Key ID: A82ED75A8DFC50A4
10 changed files with 139 additions and 239 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
Cargo.lock generated
View File

@ -241,13 +241,12 @@ checksum = "5f0dc55f2d8a1a85650ac47858bb001b4c0dd73d79e3c455a842925e68d29cd3"
[[package]] [[package]]
name = "bitcoin" name = "bitcoin"
version = "0.23.0" version = "0.25.2"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6a32c9d2fa897cfbb0db45d71e3d2838666194abc4828c0f994e4b5c3bf85ba4" checksum = "aefc9be9f17185f4ebccae6575d342063f775924d57df0000edb1880c0fb7095"
dependencies = [ dependencies = [
"bech32", "bech32",
"bitcoin_hashes", "bitcoin_hashes",
"hex 0.3.2",
"secp256k1", "secp256k1",
"serde", "serde",
] ]
@ -255,27 +254,7 @@ dependencies = [
[[package]] [[package]]
name = "bitcoin-harness" name = "bitcoin-harness"
version = "0.1.0" version = "0.1.0"
source = "git+https://github.com/d4nte/bitcoin-harness-rs?rev=2869620689f7e54bdb8ab3d1838560cb9bc8fd60#2869620689f7e54bdb8ab3d1838560cb9bc8fd60" source = "git+https://github.com/d4nte/bitcoin-harness-rs?branch=rust-bitcoin-0.25#e773e37a070fb38f982c5b80919071420e4ead21"
dependencies = [
"base64 0.12.3",
"bitcoin",
"bitcoincore-rpc-json",
"futures",
"hex 0.4.2",
"reqwest",
"serde",
"serde_json",
"testcontainers",
"thiserror",
"tokio",
"tracing",
"url",
]
[[package]]
name = "bitcoin-harness"
version = "0.1.0"
source = "git+https://github.com/coblox/bitcoin-harness-rs?rev=3be644cd9512c157d3337a189298b8257ed54d04#3be644cd9512c157d3337a189298b8257ed54d04"
dependencies = [ dependencies = [
"base64 0.12.3", "base64 0.12.3",
"bitcoin", "bitcoin",
@ -294,18 +273,18 @@ dependencies = [
[[package]] [[package]]
name = "bitcoin_hashes" name = "bitcoin_hashes"
version = "0.7.6" version = "0.9.4"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b375d62f341cef9cd9e77793ec8f1db3fc9ce2e4d57e982c8fe697a2c16af3b6" checksum = "0aaf87b776808e26ae93289bc7d025092b6d909c193f0cdee0b3a86e7bd3c776"
dependencies = [ dependencies = [
"serde", "serde",
] ]
[[package]] [[package]]
name = "bitcoincore-rpc-json" name = "bitcoincore-rpc-json"
version = "0.11.0" version = "0.12.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ea6d55f23cd516d515ae10911164c603ea1040024670ec109715a20d7f6c9d0c" checksum = "76d488ec31e9cb6726c361be5160f7d2aaace89a0681acf1f476b8fada770b6e"
dependencies = [ dependencies = [
"bitcoin", "bitcoin",
"hex 0.3.2", "hex 0.3.2",
@ -626,7 +605,7 @@ dependencies = [
[[package]] [[package]]
name = "cross-curve-dleq" name = "cross-curve-dleq"
version = "0.1.0" version = "0.1.0"
source = "git+https://github.com/comit-network/cross-curve-dleq?rev=a19608734da1e8803cb4c806022483df4e7d5588#a19608734da1e8803cb4c806022483df4e7d5588" source = "git+https://github.com/comit-network/cross-curve-dleq?rev=b43c73ac93a79fdce90cd11a458564c613048f0e#b43c73ac93a79fdce90cd11a458564c613048f0e"
dependencies = [ dependencies = [
"bit-vec", "bit-vec",
"curve25519-dalek 2.1.0", "curve25519-dalek 2.1.0",
@ -846,7 +825,7 @@ checksum = "134951f4028bdadb9b84baf4232681efbf277da25144b9b0ad65df75946c422b"
[[package]] [[package]]
name = "ecdsa_fun" name = "ecdsa_fun"
version = "0.3.2-alpha.0" version = "0.3.2-alpha.0"
source = "git+https://github.com/LLFourn/secp256kfun?rev=510d48ef6a2b19805f7f5c70c598e5b03f668e7a#510d48ef6a2b19805f7f5c70c598e5b03f668e7a" source = "git+https://github.com/LLFourn/secp256kfun?rev=cdfbc766045ea678a41780919d6228dd5acee3be#cdfbc766045ea678a41780919d6228dd5acee3be"
dependencies = [ dependencies = [
"secp256kfun", "secp256kfun",
"serde", "serde",
@ -1960,9 +1939,9 @@ dependencies = [
[[package]] [[package]]
name = "miniscript" name = "miniscript"
version = "1.0.0" version = "4.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "58f196216a07ade53d91a263b3721057f1f0cfd6f95f3d324626f3f9cf7cdfce" checksum = "cc7da049151be4bc7f8da628f5e862e6fae3fe5d7c8201a746cb8373735e789b"
dependencies = [ dependencies = [
"bitcoin", "bitcoin",
"serde", "serde",
@ -2947,9 +2926,9 @@ checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
[[package]] [[package]]
name = "secp256k1" name = "secp256k1"
version = "0.17.2" version = "0.19.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2932dc07acd2066ff2e3921a4419606b220ba6cd03a9935123856cc534877056" checksum = "c6179428c22c73ac0fbb7b5579a56353ce78ba29759b3b8575183336ea74cdfb"
dependencies = [ dependencies = [
"rand 0.6.5", "rand 0.6.5",
"secp256k1-sys", "secp256k1-sys",
@ -2958,9 +2937,9 @@ dependencies = [
[[package]] [[package]]
name = "secp256k1-sys" name = "secp256k1-sys"
version = "0.1.2" version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7ab2c26f0d3552a0f12e639ae8a64afc2e3db9c52fe32f5fc6c289d38519f220" checksum = "11553d210db090930f4432bea123b31f70bbf693ace14504ea2a35e796c28dd2"
dependencies = [ dependencies = [
"cc", "cc",
] ]
@ -2968,7 +2947,7 @@ dependencies = [
[[package]] [[package]]
name = "secp256kfun" name = "secp256kfun"
version = "0.3.2-alpha.0" version = "0.3.2-alpha.0"
source = "git+https://github.com/LLFourn/secp256kfun?rev=510d48ef6a2b19805f7f5c70c598e5b03f668e7a#510d48ef6a2b19805f7f5c70c598e5b03f668e7a" source = "git+https://github.com/LLFourn/secp256kfun?rev=cdfbc766045ea678a41780919d6228dd5acee3be#cdfbc766045ea678a41780919d6228dd5acee3be"
dependencies = [ dependencies = [
"digest 0.9.0", "digest 0.9.0",
"rand_core 0.5.1", "rand_core 0.5.1",
@ -2980,9 +2959,8 @@ dependencies = [
[[package]] [[package]]
name = "secp256kfun_parity_backend" name = "secp256kfun_parity_backend"
version = "0.1.2" version = "0.1.3-alpha.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "git+https://github.com/LLFourn/secp256kfun?rev=cdfbc766045ea678a41780919d6228dd5acee3be#cdfbc766045ea678a41780919d6228dd5acee3be"
checksum = "959911ff66eae1b170a4eec00aa9b987647ad604dc57982014d85e635b7b4f99"
dependencies = [ dependencies = [
"crunchy 0.2.2", "crunchy 0.2.2",
"subtle 2.3.0", "subtle 2.3.0",
@ -3389,7 +3367,7 @@ dependencies = [
"backoff", "backoff",
"base64 0.12.3", "base64 0.12.3",
"bitcoin", "bitcoin",
"bitcoin-harness 0.1.0 (git+https://github.com/d4nte/bitcoin-harness-rs?rev=2869620689f7e54bdb8ab3d1838560cb9bc8fd60)", "bitcoin-harness",
"conquer-once", "conquer-once",
"derivative", "derivative",
"ecdsa_fun", "ecdsa_fun",
@ -4167,7 +4145,7 @@ dependencies = [
"backoff", "backoff",
"base64 0.12.3", "base64 0.12.3",
"bitcoin", "bitcoin",
"bitcoin-harness 0.1.0 (git+https://github.com/coblox/bitcoin-harness-rs?rev=3be644cd9512c157d3337a189298b8257ed54d04)", "bitcoin-harness",
"conquer-once", "conquer-once",
"cross-curve-dleq", "cross-curve-dleq",
"curve25519-dalek 2.1.0", "curve25519-dalek 2.1.0",

6
swap/Cargo.toml
View File

@ -12,11 +12,11 @@ async-trait = "0.1"
atty = "0.2" atty = "0.2"
backoff = { version = "0.2", features = ["tokio"] } backoff = { version = "0.2", features = ["tokio"] }
base64 = "0.12" base64 = "0.12"
bitcoin = { version = "0.23", features = ["rand", "use-serde"] } # TODO: Upgrade other crates in this repo to use this version. bitcoin = { version = "0.25", features = ["rand", "use-serde"] }
bitcoin-harness = { git = "https://github.com/d4nte/bitcoin-harness-rs", rev = "2869620689f7e54bdb8ab3d1838560cb9bc8fd60" } bitcoin-harness = { git = "https://github.com/d4nte/bitcoin-harness-rs", branch = "rust-bitcoin-0.25" }
conquer-once = "0.3" conquer-once = "0.3"
derivative = "2" derivative = "2"
ecdsa_fun = { git = "https://github.com/LLFourn/secp256kfun", rev = "510d48ef6a2b19805f7f5c70c598e5b03f668e7a", features = ["libsecp_compat", "serde", "serialization"] } ecdsa_fun = { git = "https://github.com/LLFourn/secp256kfun", rev = "cdfbc766045ea678a41780919d6228dd5acee3be", features = ["libsecp_compat", "serde"] }
futures = { version = "0.3", default-features = false } futures = { version = "0.3", default-features = false }
genawaiter = "0.99.1" genawaiter = "0.99.1"
libp2p = { version = "0.29", default-features = false, features = ["tcp-tokio", "yamux", "mplex", "dns", "noise", "request-response"] } libp2p = { version = "0.29", default-features = false, features = ["tcp-tokio", "yamux", "mplex", "dns", "noise", "request-response"] }

10
swap/src/alice/execution.rs
View File

@ -207,7 +207,7 @@ pub fn build_bitcoin_redeem_transaction(
let tx_redeem = bitcoin::TxRedeem::new(tx_lock, redeem_address); let tx_redeem = bitcoin::TxRedeem::new(tx_lock, redeem_address);
bitcoin::verify_encsig( bitcoin::verify_encsig(
B.clone(), B,
s_a.into_secp256k1().into(), s_a.into_secp256k1().into(),
&tx_redeem.digest(), &tx_redeem.digest(),
&encrypted_signature, &encrypted_signature,
@ -258,7 +258,7 @@ where
.await; .await;
poll_until_block_height_is_gte(bitcoin_wallet.as_ref(), tx_lock_height + refund_timelock).await; poll_until_block_height_is_gte(bitcoin_wallet.as_ref(), tx_lock_height + refund_timelock).await;
let tx_cancel = bitcoin::TxCancel::new(&tx_lock, refund_timelock, a.public(), B.clone()); let tx_cancel = bitcoin::TxCancel::new(&tx_lock, refund_timelock, a.public(), B);
// If Bob hasn't yet broadcasted the tx cancel, we do it // If Bob hasn't yet broadcasted the tx cancel, we do it
if bitcoin_wallet if bitcoin_wallet
@ -274,7 +274,7 @@ where
let tx_cancel = tx_cancel let tx_cancel = tx_cancel
.clone() .clone()
.add_signatures(&tx_lock, (a.public(), sig_a), (B.clone(), sig_b)) .add_signatures(&tx_lock, (a.public(), sig_a), (B, sig_b))
.expect("sig_{a,b} to be valid signatures for tx_cancel"); .expect("sig_{a,b} to be valid signatures for tx_cancel");
// TODO(Franck): Error handling is delicate, why can't we broadcast? // TODO(Franck): Error handling is delicate, why can't we broadcast?
@ -331,7 +331,7 @@ pub fn extract_monero_private_key(
let tx_refund_sig = tx_refund let tx_refund_sig = tx_refund
.extract_signature_by_key(published_refund_tx, a.public()) .extract_signature_by_key(published_refund_tx, a.public())
.context("Failed to extract signature from Bitcoin refund tx")?; .context("Failed to extract signature from Bitcoin refund tx")?;
let tx_refund_encsig = a.encsign(S_b_bitcoin.clone(), tx_refund.digest()); let tx_refund_encsig = a.encsign(S_b_bitcoin, tx_refund.digest());
let s_b = bitcoin::recover(S_b_bitcoin, tx_refund_sig, tx_refund_encsig) let s_b = bitcoin::recover(S_b_bitcoin, tx_refund_sig, tx_refund_encsig)
.context("Failed to recover Monero secret key from Bitcoin signature")?; .context("Failed to recover Monero secret key from Bitcoin signature")?;
@ -351,7 +351,7 @@ pub fn build_bitcoin_punish_transaction(
a: bitcoin::SecretKey, a: bitcoin::SecretKey,
B: bitcoin::PublicKey, B: bitcoin::PublicKey,
) -> Result<bitcoin::Transaction> { ) -> Result<bitcoin::Transaction> {
let tx_cancel = bitcoin::TxCancel::new(&tx_lock, refund_timelock, a.public(), B.clone()); let tx_cancel = bitcoin::TxCancel::new(&tx_lock, refund_timelock, a.public(), B);
let tx_punish = bitcoin::TxPunish::new(&tx_cancel, &punish_address, punish_timelock); let tx_punish = bitcoin::TxPunish::new(&tx_cancel, &punish_address, punish_timelock);
let sig_a = a.sign(tx_punish.digest()); let sig_a = a.sign(tx_punish.digest());

6
swap/src/alice/swap.rs
View File

@ -208,7 +208,7 @@ pub async fn swap(
&state3.tx_lock, &state3.tx_lock,
state3.a.clone(), state3.a.clone(),
state3.s_a, state3.s_a,
state3.B.clone(), state3.B,
&state3.redeem_address, &state3.redeem_address,
) { ) {
Ok(tx) => tx, Ok(tx) => tx,
@ -243,7 +243,7 @@ pub async fn swap(
let tx_cancel = publish_cancel_transaction( let tx_cancel = publish_cancel_transaction(
state3.tx_lock.clone(), state3.tx_lock.clone(),
state3.a.clone(), state3.a.clone(),
state3.B.clone(), state3.B,
state3.refund_timelock, state3.refund_timelock,
state3.tx_cancel_sig_bob.clone(), state3.tx_cancel_sig_bob.clone(),
bitcoin_wallet.clone(), bitcoin_wallet.clone(),
@ -329,7 +329,7 @@ pub async fn swap(
state3.punish_timelock, state3.punish_timelock,
state3.tx_punish_sig_bob.clone(), state3.tx_punish_sig_bob.clone(),
state3.a.clone(), state3.a.clone(),
state3.B.clone(), state3.B,
)?; )?;
let punish_tx_finalised = publish_bitcoin_punish_transaction( let punish_tx_finalised = publish_bitcoin_punish_transaction(

55
swap/src/recover.rs
View File

@ -55,7 +55,7 @@ pub async fn alice_recover(
&state.tx_lock, &state.tx_lock,
state.refund_timelock, state.refund_timelock,
state.a.public(), state.a.public(),
state.B.clone(), state.B,
); );
info!("Checking if the Bitcoin cancel transaction has been published"); info!("Checking if the Bitcoin cancel transaction has been published");
@ -81,11 +81,7 @@ pub async fn alice_recover(
let tx_cancel = tx_cancel let tx_cancel = tx_cancel
.clone() .clone()
.add_signatures( .add_signatures(&state.tx_lock, (state.a.public(), sig_a), (state.B, sig_b))
&state.tx_lock,
(state.a.public(), sig_a),
(state.B.clone(), sig_b),
)
.expect("sig_{a,b} to be valid signatures for tx_cancel"); .expect("sig_{a,b} to be valid signatures for tx_cancel");
// TODO: We should not fail if the transaction is already on the blockchain // TODO: We should not fail if the transaction is already on the blockchain
@ -123,9 +119,7 @@ pub async fn alice_recover(
let tx_refund_sig = tx_refund let tx_refund_sig = tx_refund
.extract_signature_by_key(tx_refund_published, state.a.public())?; .extract_signature_by_key(tx_refund_published, state.a.public())?;
let tx_refund_encsig = state let tx_refund_encsig = state.a.encsign(state.S_b_bitcoin, tx_refund.digest());
.a
.encsign(state.S_b_bitcoin.clone(), tx_refund.digest());
let s_b = bitcoin::recover(state.S_b_bitcoin, tx_refund_sig, tx_refund_encsig)?; let s_b = bitcoin::recover(state.S_b_bitcoin, tx_refund_sig, tx_refund_encsig)?;
let s_b = monero::PrivateKey::from_scalar( let s_b = monero::PrivateKey::from_scalar(
@ -152,7 +146,7 @@ pub async fn alice_recover(
let sig_tx_punish = tx_punish.add_signatures( let sig_tx_punish = tx_punish.add_signatures(
&tx_cancel, &tx_cancel,
(state.a.public(), sig_a), (state.a.public(), sig_a),
(state.B.clone(), sig_b), (state.B, sig_b),
)?; )?;
bitcoin_wallet bitcoin_wallet
@ -187,7 +181,7 @@ pub async fn alice_recover(
&state.tx_lock, &state.tx_lock,
state.refund_timelock, state.refund_timelock,
state.a.public(), state.a.public(),
state.B.clone(), state.B,
); );
info!("Checking if the Bitcoin cancel transaction has been published"); info!("Checking if the Bitcoin cancel transaction has been published");
@ -202,11 +196,7 @@ pub async fn alice_recover(
let tx_cancel = tx_cancel let tx_cancel = tx_cancel
.clone() .clone()
.add_signatures( .add_signatures(&state.tx_lock, (state.a.public(), sig_a), (state.B, sig_b))
&state.tx_lock,
(state.a.public(), sig_a),
(state.B.clone(), sig_b),
)
.expect("sig_{a,b} to be valid signatures for tx_cancel"); .expect("sig_{a,b} to be valid signatures for tx_cancel");
// TODO: We should not fail if the transaction is already on the blockchain // TODO: We should not fail if the transaction is already on the blockchain
@ -244,9 +234,8 @@ pub async fn alice_recover(
let tx_refund_sig = tx_refund let tx_refund_sig = tx_refund
.extract_signature_by_key(tx_refund_published, state.a.public())?; .extract_signature_by_key(tx_refund_published, state.a.public())?;
let tx_refund_encsig = state let tx_refund_encsig =
.a state.a.encsign(state.S_b_bitcoin, tx_refund.digest());
.encsign(state.S_b_bitcoin.clone(), tx_refund.digest());
let s_b = let s_b =
bitcoin::recover(state.S_b_bitcoin, tx_refund_sig, tx_refund_encsig)?; bitcoin::recover(state.S_b_bitcoin, tx_refund_sig, tx_refund_encsig)?;
@ -274,7 +263,7 @@ pub async fn alice_recover(
let sig_tx_punish = tx_punish.add_signatures( let sig_tx_punish = tx_punish.add_signatures(
&tx_cancel, &tx_cancel,
(state.a.public(), sig_a), (state.a.public(), sig_a),
(state.B.clone(), sig_b), (state.B, sig_b),
)?; )?;
bitcoin_wallet bitcoin_wallet
@ -292,7 +281,7 @@ pub async fn alice_recover(
&state.tx_lock, &state.tx_lock,
state.refund_timelock, state.refund_timelock,
state.a.public(), state.a.public(),
state.B.clone(), state.B,
); );
let tx_refund = bitcoin::TxRefund::new(&tx_cancel, &state.refund_address); let tx_refund = bitcoin::TxRefund::new(&tx_cancel, &state.refund_address);
@ -310,9 +299,7 @@ pub async fn alice_recover(
let tx_refund_sig = tx_refund let tx_refund_sig = tx_refund
.extract_signature_by_key(tx_refund_published, state.a.public())?; .extract_signature_by_key(tx_refund_published, state.a.public())?;
let tx_refund_encsig = state let tx_refund_encsig = state.a.encsign(state.S_b_bitcoin, tx_refund.digest());
.a
.encsign(state.S_b_bitcoin.clone(), tx_refund.digest());
let s_b = bitcoin::recover(state.S_b_bitcoin, tx_refund_sig, tx_refund_encsig)?; let s_b = bitcoin::recover(state.S_b_bitcoin, tx_refund_sig, tx_refund_encsig)?;
let s_b = monero::PrivateKey::from_scalar( let s_b = monero::PrivateKey::from_scalar(
@ -339,7 +326,7 @@ pub async fn alice_recover(
let sig_tx_punish = tx_punish.add_signatures( let sig_tx_punish = tx_punish.add_signatures(
&tx_cancel, &tx_cancel,
(state.a.public(), sig_a), (state.a.public(), sig_a),
(state.B.clone(), sig_b), (state.B, sig_b),
)?; )?;
bitcoin_wallet bitcoin_wallet
@ -381,7 +368,7 @@ pub async fn bob_recover(
let tx_cancel = bitcoin::TxCancel::new( let tx_cancel = bitcoin::TxCancel::new(
&state.tx_lock, &state.tx_lock,
state.refund_timelock, state.refund_timelock,
state.A.clone(), state.A,
state.b.public(), state.b.public(),
); );
@ -408,11 +395,7 @@ pub async fn bob_recover(
let tx_cancel = tx_cancel let tx_cancel = tx_cancel
.clone() .clone()
.add_signatures( .add_signatures(&state.tx_lock, (state.A, sig_a), (state.b.public(), sig_b))
&state.tx_lock,
(state.A.clone(), sig_a),
(state.b.public(), sig_b),
)
.expect("sig_{a,b} to be valid signatures for tx_cancel"); .expect("sig_{a,b} to be valid signatures for tx_cancel");
// TODO: We should not fail if the transaction is already on the blockchain // TODO: We should not fail if the transaction is already on the blockchain
@ -431,11 +414,7 @@ pub async fn bob_recover(
let sig_b = state.b.sign(tx_refund.digest()); let sig_b = state.b.sign(tx_refund.digest());
tx_refund tx_refund
.add_signatures( .add_signatures(&tx_cancel, (state.A, sig_a), (state.b.public(), sig_b))
&tx_cancel,
(state.A.clone(), sig_a),
(state.b.public(), sig_b),
)
.expect("sig_{a,b} to be valid signatures for tx_refund") .expect("sig_{a,b} to be valid signatures for tx_refund")
}; };
@ -455,9 +434,7 @@ pub async fn bob_recover(
.get_raw_transaction(tx_redeem.txid()) .get_raw_transaction(tx_redeem.txid())
.await?; .await?;
let tx_redeem_encsig = state let tx_redeem_encsig = state.b.encsign(state.S_a_bitcoin, tx_redeem.digest());
.b
.encsign(state.S_a_bitcoin.clone(), tx_redeem.digest());
let tx_redeem_sig = let tx_redeem_sig =
tx_redeem.extract_signature_by_key(tx_redeem_published, state.b.public())?; tx_redeem.extract_signature_by_key(tx_redeem_published, state.b.public())?;

10
xmr-btc/Cargo.toml
View File

@ -9,15 +9,15 @@ edition = "2018"
[dependencies] [dependencies]
anyhow = "1" anyhow = "1"
async-trait = "0.1" async-trait = "0.1"
bitcoin = { version = "0.23", features = ["rand", "serde"] } bitcoin = { version = "0.25", features = ["rand", "serde"] }
conquer-once = "0.3" conquer-once = "0.3"
cross-curve-dleq = { git = "https://github.com/comit-network/cross-curve-dleq", rev = "a19608734da1e8803cb4c806022483df4e7d5588", features = ["serde"] } cross-curve-dleq = { git = "https://github.com/comit-network/cross-curve-dleq", rev = "b43c73ac93a79fdce90cd11a458564c613048f0e", features = ["serde"] }
curve25519-dalek = "2" curve25519-dalek = "2"
ecdsa_fun = { git = "https://github.com/LLFourn/secp256kfun", rev = "510d48ef6a2b19805f7f5c70c598e5b03f668e7a", features = ["libsecp_compat", "serde", "serialization"] } ecdsa_fun = { git = "https://github.com/LLFourn/secp256kfun", rev = "cdfbc766045ea678a41780919d6228dd5acee3be", features = ["libsecp_compat", "serde"] }
ed25519-dalek = { version = "1.0.0-pre.4", features = ["serde"] }# Cannot be 1 because they depend on curve25519-dalek version 3 ed25519-dalek = { version = "1.0.0-pre.4", features = ["serde"] }# Cannot be 1 because they depend on curve25519-dalek version 3
futures = "0.3" futures = "0.3"
genawaiter = "0.99.1" genawaiter = "0.99.1"
miniscript = { version = "1", features = ["serde"] } miniscript = { version = "4", features = ["serde"] }
monero = { version = "0.9", features = ["serde_support"] } monero = { version = "0.9", features = ["serde_support"] }
rand = "0.7" rand = "0.7"
serde = { version = "1", features = ["derive"] } serde = { version = "1", features = ["derive"] }
@ -29,7 +29,7 @@ tracing = "0.1"
[dev-dependencies] [dev-dependencies]
backoff = { version = "0.2", features = ["tokio"] } backoff = { version = "0.2", features = ["tokio"] }
base64 = "0.12" base64 = "0.12"
bitcoin-harness = { git = "https://github.com/coblox/bitcoin-harness-rs", rev = "3be644cd9512c157d3337a189298b8257ed54d04" } bitcoin-harness = { git = "https://github.com/d4nte/bitcoin-harness-rs", branch = "rust-bitcoin-0.25" }
futures = "0.3" futures = "0.3"
monero-harness = { path = "../monero-harness" } monero-harness = { path = "../monero-harness" }
reqwest = { version = "0.10", default-features = false } reqwest = { version = "0.10", default-features = false }

66
xmr-btc/src/alice.rs
View File

@ -179,7 +179,7 @@ where
let tx_redeem = bitcoin::TxRedeem::new(&tx_lock, &redeem_address); let tx_redeem = bitcoin::TxRedeem::new(&tx_lock, &redeem_address);
bitcoin::verify_encsig( bitcoin::verify_encsig(
B.clone(), B,
s_a.into_secp256k1().into(), s_a.into_secp256k1().into(),
&tx_redeem.digest(), &tx_redeem.digest(),
&tx_redeem_encsig, &tx_redeem_encsig,
@ -191,7 +191,7 @@ where
adaptor.decrypt_signature(&s_a.into_secp256k1(), tx_redeem_encsig.clone()); adaptor.decrypt_signature(&s_a.into_secp256k1(), tx_redeem_encsig.clone());
let tx = tx_redeem let tx = tx_redeem
.add_signatures(&tx_lock, (a.public(), sig_a), (B.clone(), sig_b)) .add_signatures(&tx_lock, (a.public(), sig_a), (B, sig_b))
.expect("sig_{a,b} to be valid signatures for tx_redeem"); .expect("sig_{a,b} to be valid signatures for tx_redeem");
let txid = tx.txid(); let txid = tx.txid();
@ -220,15 +220,14 @@ where
if let Err(SwapFailed::AfterXmrLock(Reason::BtcExpired)) = swap_result { if let Err(SwapFailed::AfterXmrLock(Reason::BtcExpired)) = swap_result {
let refund_result: Result<(), RefundFailed> = async { let refund_result: Result<(), RefundFailed> = async {
let tx_cancel = let tx_cancel = bitcoin::TxCancel::new(&tx_lock, refund_timelock, a.public(), B);
bitcoin::TxCancel::new(&tx_lock, refund_timelock, a.public(), B.clone());
let signed_tx_cancel = { let signed_tx_cancel = {
let sig_a = a.sign(tx_cancel.digest()); let sig_a = a.sign(tx_cancel.digest());
let sig_b = tx_cancel_sig_bob.clone(); let sig_b = tx_cancel_sig_bob.clone();
tx_cancel tx_cancel
.clone() .clone()
.add_signatures(&tx_lock, (a.public(), sig_a), (B.clone(), sig_b)) .add_signatures(&tx_lock, (a.public(), sig_a), (B, sig_b))
.expect("sig_{a,b} to be valid signatures for tx_cancel") .expect("sig_{a,b} to be valid signatures for tx_cancel")
}; };
@ -266,7 +265,7 @@ where
let tx_refund_sig = tx_refund let tx_refund_sig = tx_refund
.extract_signature_by_key(tx_refund_published, a.public()) .extract_signature_by_key(tx_refund_published, a.public())
.map_err(|_| RefundFailed::BtcRefundSignature)?; .map_err(|_| RefundFailed::BtcRefundSignature)?;
let tx_refund_encsig = a.encsign(S_b_bitcoin.clone(), tx_refund.digest()); let tx_refund_encsig = a.encsign(S_b_bitcoin, tx_refund.digest());
let s_b = bitcoin::recover(S_b_bitcoin, tx_refund_sig, tx_refund_encsig) let s_b = bitcoin::recover(S_b_bitcoin, tx_refund_sig, tx_refund_encsig)
.map_err(|_| RefundFailed::SecretRecovery)?; .map_err(|_| RefundFailed::SecretRecovery)?;
@ -292,8 +291,7 @@ where
// with the refund on Monero. Doing so may be too verbose with the current, // with the refund on Monero. Doing so may be too verbose with the current,
// linear approach. A different design may be required // linear approach. A different design may be required
if let Err(RefundFailed::BtcPunishable) = refund_result { if let Err(RefundFailed::BtcPunishable) = refund_result {
let tx_cancel = let tx_cancel = bitcoin::TxCancel::new(&tx_lock, refund_timelock, a.public(), B);
bitcoin::TxCancel::new(&tx_lock, refund_timelock, a.public(), B.clone());
let tx_punish = let tx_punish =
bitcoin::TxPunish::new(&tx_cancel, &punish_address, punish_timelock); bitcoin::TxPunish::new(&tx_cancel, &punish_address, punish_timelock);
let tx_punish_txid = tx_punish.txid(); let tx_punish_txid = tx_punish.txid();
@ -580,12 +578,8 @@ pub struct State2 {
impl State2 { impl State2 {
pub fn next_message(&self) -> Message1 { pub fn next_message(&self) -> Message1 {
let tx_cancel = bitcoin::TxCancel::new( let tx_cancel =
&self.tx_lock, bitcoin::TxCancel::new(&self.tx_lock, self.refund_timelock, self.a.public(), self.B);
self.refund_timelock,
self.a.public(),
self.B.clone(),
);
let tx_refund = bitcoin::TxRefund::new(&tx_cancel, &self.refund_address); let tx_refund = bitcoin::TxRefund::new(&tx_cancel, &self.refund_address);
// Alice encsigns the refund transaction(bitcoin) digest with Bob's monero // Alice encsigns the refund transaction(bitcoin) digest with Bob's monero
@ -593,7 +587,7 @@ impl State2 {
// tx_lock_bitcoin to Bob's refund address. // tx_lock_bitcoin to Bob's refund address.
// recover(encsign(a, S_b, d), sign(a, d), S_b) = s_b where d is a digest, (a, // recover(encsign(a, S_b, d), sign(a, d), S_b) = s_b where d is a digest, (a,
// A) is alice's keypair and (s_b, S_b) is bob's keypair. // A) is alice's keypair and (s_b, S_b) is bob's keypair.
let tx_refund_encsig = self.a.encsign(self.S_b_bitcoin.clone(), tx_refund.digest()); let tx_refund_encsig = self.a.encsign(self.S_b_bitcoin, tx_refund.digest());
let tx_cancel_sig = self.a.sign(tx_cancel.digest()); let tx_cancel_sig = self.a.sign(tx_cancel.digest());
Message1 { Message1 {
@ -603,12 +597,8 @@ impl State2 {
} }
pub fn receive(self, msg: bob::Message2) -> Result<State3> { pub fn receive(self, msg: bob::Message2) -> Result<State3> {
let tx_cancel = bitcoin::TxCancel::new( let tx_cancel =
&self.tx_lock, bitcoin::TxCancel::new(&self.tx_lock, self.refund_timelock, self.a.public(), self.B);
self.refund_timelock,
self.a.public(),
self.B.clone(),
);
bitcoin::verify_sig(&self.B, &tx_cancel.digest(), &msg.tx_cancel_sig)?; bitcoin::verify_sig(&self.B, &tx_cancel.digest(), &msg.tx_cancel_sig)?;
let tx_punish = let tx_punish =
bitcoin::TxPunish::new(&tx_cancel, &self.punish_address, self.punish_timelock); bitcoin::TxPunish::new(&tx_cancel, &self.punish_address, self.punish_timelock);
@ -751,12 +741,8 @@ impl State4 {
&self, &self,
bitcoin_wallet: &W, bitcoin_wallet: &W,
) -> Result<()> { ) -> Result<()> {
let tx_cancel = bitcoin::TxCancel::new( let tx_cancel =
&self.tx_lock, bitcoin::TxCancel::new(&self.tx_lock, self.refund_timelock, self.a.public(), self.B);
self.refund_timelock,
self.a.public(),
self.B.clone(),
);
let tx_punish = let tx_punish =
bitcoin::TxPunish::new(&tx_cancel, &self.punish_address, self.punish_timelock); bitcoin::TxPunish::new(&tx_cancel, &self.punish_address, self.punish_timelock);
@ -767,7 +753,7 @@ impl State4 {
let signed_tx_cancel = tx_cancel.clone().add_signatures( let signed_tx_cancel = tx_cancel.clone().add_signatures(
&self.tx_lock, &self.tx_lock,
(self.a.public(), sig_a), (self.a.public(), sig_a),
(self.B.clone(), sig_b), (self.B, sig_b),
)?; )?;
let _ = bitcoin_wallet let _ = bitcoin_wallet
@ -779,11 +765,8 @@ impl State4 {
let sig_a = self.a.sign(tx_punish.digest()); let sig_a = self.a.sign(tx_punish.digest());
let sig_b = self.tx_punish_sig_bob.clone(); let sig_b = self.tx_punish_sig_bob.clone();
let signed_tx_punish = tx_punish.add_signatures( let signed_tx_punish =
&tx_cancel, tx_punish.add_signatures(&tx_cancel, (self.a.public(), sig_a), (self.B, sig_b))?;
(self.a.public(), sig_a),
(self.B.clone(), sig_b),
)?;
let _ = bitcoin_wallet let _ = bitcoin_wallet
.broadcast_signed_transaction(signed_tx_punish) .broadcast_signed_transaction(signed_tx_punish)
@ -854,16 +837,12 @@ impl State5 {
B: WatchForRawTransaction, B: WatchForRawTransaction,
M: CreateWalletForOutput, M: CreateWalletForOutput,
{ {
let tx_cancel = bitcoin::TxCancel::new( let tx_cancel =
&self.tx_lock, bitcoin::TxCancel::new(&self.tx_lock, self.refund_timelock, self.a.public(), self.B);
self.refund_timelock,
self.a.public(),
self.B.clone(),
);
let tx_refund = bitcoin::TxRefund::new(&tx_cancel, &self.refund_address); let tx_refund = bitcoin::TxRefund::new(&tx_cancel, &self.refund_address);
let tx_refund_encsig = self.a.encsign(self.S_b_bitcoin.clone(), tx_refund.digest()); let tx_refund_encsig = self.a.encsign(self.S_b_bitcoin, tx_refund.digest());
let tx_refund_candidate = bitcoin_wallet let tx_refund_candidate = bitcoin_wallet
.watch_for_raw_transaction(tx_refund.txid()) .watch_for_raw_transaction(tx_refund.txid())
@ -923,11 +902,8 @@ impl State6 {
let sig_b = let sig_b =
adaptor.decrypt_signature(&self.s_a.into_secp256k1(), self.tx_redeem_encsig.clone()); adaptor.decrypt_signature(&self.s_a.into_secp256k1(), self.tx_redeem_encsig.clone());
let sig_tx_redeem = tx_redeem.add_signatures( let sig_tx_redeem =
&self.tx_lock, tx_redeem.add_signatures(&self.tx_lock, (self.a.public(), sig_a), (self.B, sig_b))?;
(self.a.public(), sig_a),
(self.B.clone(), sig_b),
)?;
bitcoin_wallet bitcoin_wallet
.broadcast_signed_transaction(sig_tx_redeem) .broadcast_signed_transaction(sig_tx_redeem)
.await?; .await?;

4
xmr-btc/src/bitcoin.rs
View File

@ -37,7 +37,7 @@ impl SecretKey {
} }
pub fn public(&self) -> PublicKey { pub fn public(&self) -> PublicKey {
PublicKey(self.public.clone()) PublicKey(self.public)
} }
pub fn to_bytes(&self) -> [u8; 32] { pub fn to_bytes(&self) -> [u8; 32] {
@ -72,7 +72,7 @@ impl SecretKey {
} }
} }
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] #[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq)]
pub struct PublicKey(Point); pub struct PublicKey(Point);
impl From<PublicKey> for Point { impl From<PublicKey> for Point {

79
xmr-btc/src/bitcoin/transactions.rs
View File

@ -3,11 +3,11 @@ use crate::bitcoin::{
}; };
use anyhow::{bail, Context, Result}; use anyhow::{bail, Context, Result};
use bitcoin::{ use bitcoin::{
util::{bip143::SighashComponents, psbt::PartiallySignedTransaction}, util::{bip143::SigHashCache, psbt::PartiallySignedTransaction},
Address, Amount, Network, SigHash, Transaction, TxIn, TxOut, Address, Amount, Network, SigHash, SigHashType, Transaction, TxIn, TxOut,
}; };
use ecdsa_fun::Signature; use ecdsa_fun::Signature;
use miniscript::Descriptor; use miniscript::{Descriptor, NullCtx};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use std::collections::HashMap; use std::collections::HashMap;
@ -24,7 +24,7 @@ impl TxLock {
{ {
let lock_output_descriptor = build_shared_output_descriptor(A.0, B.0); let lock_output_descriptor = build_shared_output_descriptor(A.0, B.0);
let address = lock_output_descriptor let address = lock_output_descriptor
.address(Network::Regtest) .address(Network::Regtest, NullCtx)
.expect("can derive address from descriptor"); .expect("can derive address from descriptor");
// We construct a psbt for convenience // We construct a psbt for convenience
@ -59,7 +59,9 @@ impl TxLock {
self.inner self.inner
.output .output
.iter() .iter()
.position(|output| output.script_pubkey == self.output_descriptor.script_pubkey()) .position(|output| {
output.script_pubkey == self.output_descriptor.script_pubkey(NullCtx)
})
.expect("transaction contains lock output") .expect("transaction contains lock output")
} }
@ -67,7 +69,7 @@ impl TxLock {
&self, &self,
spend_address: &Address, spend_address: &Address,
sequence: Option<u32>, sequence: Option<u32>,
) -> (Transaction, TxIn) { ) -> Transaction {
let previous_output = self.as_outpoint(); let previous_output = self.as_outpoint();
let tx_in = TxIn { let tx_in = TxIn {
@ -82,14 +84,12 @@ impl TxLock {
script_pubkey: spend_address.script_pubkey(), script_pubkey: spend_address.script_pubkey(),
}; };
let transaction = Transaction { Transaction {
version: 2, version: 2,
lock_time: 0, lock_time: 0,
input: vec![tx_in.clone()], input: vec![tx_in],
output: vec![tx_out], output: vec![tx_out],
}; }
(transaction, tx_in)
} }
} }
@ -109,12 +109,13 @@ impl TxRedeem {
pub fn new(tx_lock: &TxLock, redeem_address: &Address) -> Self { pub fn new(tx_lock: &TxLock, redeem_address: &Address) -> Self {
// lock_input is the shared output that is now being used as an input for the // lock_input is the shared output that is now being used as an input for the
// redeem transaction // redeem transaction
let (tx_redeem, lock_input) = tx_lock.build_spend_transaction(redeem_address, None); let tx_redeem = tx_lock.build_spend_transaction(redeem_address, None);
let digest = SighashComponents::new(&tx_redeem).sighash_all( let digest = SigHashCache::new(&tx_redeem).signature_hash(
&lock_input, 0, // Only one input: lock_input (lock transaction)
&tx_lock.output_descriptor.witness_script(), &tx_lock.output_descriptor.witness_script(NullCtx),
tx_lock.lock_amount().as_sat(), tx_lock.lock_amount().as_sat(),
SigHashType::All,
); );
Self { Self {
@ -159,7 +160,7 @@ impl TxRedeem {
let mut tx_redeem = self.inner; let mut tx_redeem = self.inner;
tx_lock tx_lock
.output_descriptor .output_descriptor
.satisfy(&mut tx_redeem.input[0], satisfier)?; .satisfy(&mut tx_redeem.input[0], satisfier, NullCtx)?;
Ok(tx_redeem) Ok(tx_redeem)
} }
@ -238,20 +239,21 @@ impl TxCancel {
let tx_out = TxOut { let tx_out = TxOut {
value: tx_lock.lock_amount().as_sat() - TX_FEE, value: tx_lock.lock_amount().as_sat() - TX_FEE,
script_pubkey: cancel_output_descriptor.script_pubkey(), script_pubkey: cancel_output_descriptor.script_pubkey(NullCtx),
}; };
let transaction = Transaction { let transaction = Transaction {
version: 2, version: 2,
lock_time: 0, lock_time: 0,
input: vec![tx_in.clone()], input: vec![tx_in],
output: vec![tx_out], output: vec![tx_out],
}; };
let digest = SighashComponents::new(&transaction).sighash_all( let digest = SigHashCache::new(&transaction).signature_hash(
&tx_in, 0, // Only one input: lock_input (lock transaction)
&tx_lock.output_descriptor.witness_script(), &tx_lock.output_descriptor.witness_script(NullCtx),
tx_lock.lock_amount().as_sat(), tx_lock.lock_amount().as_sat(),
SigHashType::All,
); );
Self { Self {
@ -305,7 +307,7 @@ impl TxCancel {
let mut tx_cancel = self.inner; let mut tx_cancel = self.inner;
tx_lock tx_lock
.output_descriptor .output_descriptor
.satisfy(&mut tx_cancel.input[0], satisfier)?; .satisfy(&mut tx_cancel.input[0], satisfier, NullCtx)?;
Ok(tx_cancel) Ok(tx_cancel)
} }
@ -314,7 +316,7 @@ impl TxCancel {
&self, &self,
spend_address: &Address, spend_address: &Address,
sequence: Option<u32>, sequence: Option<u32>,
) -> (Transaction, TxIn) { ) -> Transaction {
let previous_output = self.as_outpoint(); let previous_output = self.as_outpoint();
let tx_in = TxIn { let tx_in = TxIn {
@ -329,14 +331,12 @@ impl TxCancel {
script_pubkey: spend_address.script_pubkey(), script_pubkey: spend_address.script_pubkey(),
}; };
let transaction = Transaction { Transaction {
version: 2, version: 2,
lock_time: 0, lock_time: 0,
input: vec![tx_in.clone()], input: vec![tx_in],
output: vec![tx_out], output: vec![tx_out],
}; }
(transaction, tx_in)
} }
} }
@ -348,12 +348,13 @@ pub struct TxRefund {
impl TxRefund { impl TxRefund {
pub fn new(tx_cancel: &TxCancel, refund_address: &Address) -> Self { pub fn new(tx_cancel: &TxCancel, refund_address: &Address) -> Self {
let (tx_punish, cancel_input) = tx_cancel.build_spend_transaction(refund_address, None); let tx_punish = tx_cancel.build_spend_transaction(refund_address, None);
let digest = SighashComponents::new(&tx_punish).sighash_all( let digest = SigHashCache::new(&tx_punish).signature_hash(
&cancel_input, 0, // Only one input: cancel transaction
&tx_cancel.output_descriptor.witness_script(), &tx_cancel.output_descriptor.witness_script(NullCtx),
tx_cancel.amount().as_sat(), tx_cancel.amount().as_sat(),
SigHashType::All,
); );
Self { Self {
@ -398,7 +399,7 @@ impl TxRefund {
let mut tx_refund = self.inner; let mut tx_refund = self.inner;
tx_cancel tx_cancel
.output_descriptor .output_descriptor
.satisfy(&mut tx_refund.input[0], satisfier)?; .satisfy(&mut tx_refund.input[0], satisfier, NullCtx)?;
Ok(tx_refund) Ok(tx_refund)
} }
@ -449,13 +450,13 @@ pub struct TxPunish {
impl TxPunish { impl TxPunish {
pub fn new(tx_cancel: &TxCancel, punish_address: &Address, punish_timelock: u32) -> Self { pub fn new(tx_cancel: &TxCancel, punish_address: &Address, punish_timelock: u32) -> Self {
let (tx_punish, lock_input) = let tx_punish = tx_cancel.build_spend_transaction(punish_address, Some(punish_timelock));
tx_cancel.build_spend_transaction(punish_address, Some(punish_timelock));
let digest = SighashComponents::new(&tx_punish).sighash_all( let digest = SigHashCache::new(&tx_punish).signature_hash(
&lock_input, 0, // Only one input: cancel transaction
&tx_cancel.output_descriptor.witness_script(), &tx_cancel.output_descriptor.witness_script(NullCtx),
tx_cancel.amount().as_sat(), tx_cancel.amount().as_sat(),
SigHashType::All,
); );
Self { Self {
@ -500,7 +501,7 @@ impl TxPunish {
let mut tx_punish = self.inner; let mut tx_punish = self.inner;
tx_cancel tx_cancel
.output_descriptor .output_descriptor
.satisfy(&mut tx_punish.input[0], satisfier)?; .satisfy(&mut tx_punish.input[0], satisfier, NullCtx)?;
Ok(tx_punish) Ok(tx_punish)
} }

80
xmr-btc/src/bob.rs
View File

@ -180,7 +180,7 @@ where
} }
let tx_redeem = bitcoin::TxRedeem::new(&tx_lock, &redeem_address); let tx_redeem = bitcoin::TxRedeem::new(&tx_lock, &redeem_address);
let tx_redeem_encsig = b.encsign(S_a_bitcoin.clone(), tx_redeem.digest()); let tx_redeem_encsig = b.encsign(S_a_bitcoin, tx_redeem.digest());
co.yield_(Action::SendBtcRedeemEncsig(tx_redeem_encsig.clone())) co.yield_(Action::SendBtcRedeemEncsig(tx_redeem_encsig.clone()))
.await; .await;
@ -221,8 +221,7 @@ where
} }
if let Err(SwapFailed::AfterBtcLock(_)) = swap_result { if let Err(SwapFailed::AfterBtcLock(_)) = swap_result {
let tx_cancel = let tx_cancel = bitcoin::TxCancel::new(&tx_lock, refund_timelock, A, b.public());
bitcoin::TxCancel::new(&tx_lock, refund_timelock, A.clone(), b.public());
let tx_cancel_txid = tx_cancel.txid(); let tx_cancel_txid = tx_cancel.txid();
let signed_tx_cancel = { let signed_tx_cancel = {
let sig_a = tx_cancel_sig_a.clone(); let sig_a = tx_cancel_sig_a.clone();
@ -230,7 +229,7 @@ where
tx_cancel tx_cancel
.clone() .clone()
.add_signatures(&tx_lock, (A.clone(), sig_a), (b.public(), sig_b)) .add_signatures(&tx_lock, (A, sig_a), (b.public(), sig_b))
.expect("sig_{a,b} to be valid signatures for tx_cancel") .expect("sig_{a,b} to be valid signatures for tx_cancel")
}; };
@ -250,7 +249,7 @@ where
let sig_b = b.sign(tx_refund.digest()); let sig_b = b.sign(tx_refund.digest());
tx_refund tx_refund
.add_signatures(&tx_cancel, (A.clone(), sig_a), (b.public(), sig_b)) .add_signatures(&tx_cancel, (A, sig_a), (b.public(), sig_b))
.expect("sig_{a,b} to be valid signatures for tx_refund") .expect("sig_{a,b} to be valid signatures for tx_refund")
}; };
@ -412,8 +411,7 @@ impl State0 {
.ok_or_else(|| anyhow!("S_a is not a monero curve point"))?, .ok_or_else(|| anyhow!("S_a is not a monero curve point"))?,
)?; )?;
let tx_lock = let tx_lock = bitcoin::TxLock::new(wallet, self.btc, msg.A, self.b.public()).await?;
bitcoin::TxLock::new(wallet, self.btc, msg.A.clone(), self.b.public()).await?;
let v = msg.v_a + self.v_b; let v = msg.v_a + self.v_b;
Ok(State1 { Ok(State1 {
@ -462,17 +460,12 @@ impl State1 {
} }
pub fn receive(self, msg: alice::Message1) -> Result<State2> { pub fn receive(self, msg: alice::Message1) -> Result<State2> {
let tx_cancel = TxCancel::new( let tx_cancel = TxCancel::new(&self.tx_lock, self.refund_timelock, self.A, self.b.public());
&self.tx_lock,
self.refund_timelock,
self.A.clone(),
self.b.public(),
);
let tx_refund = bitcoin::TxRefund::new(&tx_cancel, &self.refund_address); let tx_refund = bitcoin::TxRefund::new(&tx_cancel, &self.refund_address);
bitcoin::verify_sig(&self.A, &tx_cancel.digest(), &msg.tx_cancel_sig)?; bitcoin::verify_sig(&self.A, &tx_cancel.digest(), &msg.tx_cancel_sig)?;
bitcoin::verify_encsig( bitcoin::verify_encsig(
self.A.clone(), self.A,
self.s_b.into_secp256k1().into(), self.s_b.into_secp256k1().into(),
&tx_refund.digest(), &tx_refund.digest(),
&msg.tx_refund_encsig, &msg.tx_refund_encsig,
@ -522,12 +515,7 @@ pub struct State2 {
impl State2 { impl State2 {
pub fn next_message(&self) -> Message2 { pub fn next_message(&self) -> Message2 {
let tx_cancel = TxCancel::new( let tx_cancel = TxCancel::new(&self.tx_lock, self.refund_timelock, self.A, self.b.public());
&self.tx_lock,
self.refund_timelock,
self.A.clone(),
self.b.public(),
);
let tx_cancel_sig = self.b.sign(tx_cancel.digest()); let tx_cancel_sig = self.b.sign(tx_cancel.digest());
let tx_punish = let tx_punish =
bitcoin::TxPunish::new(&tx_cancel, &self.punish_address, self.punish_timelock); bitcoin::TxPunish::new(&tx_cancel, &self.punish_address, self.punish_timelock);
@ -636,12 +624,8 @@ impl State3 {
&self, &self,
bitcoin_wallet: &W, bitcoin_wallet: &W,
) -> Result<()> { ) -> Result<()> {
let tx_cancel = bitcoin::TxCancel::new( let tx_cancel =
&self.tx_lock, bitcoin::TxCancel::new(&self.tx_lock, self.refund_timelock, self.A, self.b.public());
self.refund_timelock,
self.A.clone(),
self.b.public(),
);
let tx_refund = bitcoin::TxRefund::new(&tx_cancel, &self.refund_address); let tx_refund = bitcoin::TxRefund::new(&tx_cancel, &self.refund_address);
{ {
@ -650,7 +634,7 @@ impl State3 {
let signed_tx_cancel = tx_cancel.clone().add_signatures( let signed_tx_cancel = tx_cancel.clone().add_signatures(
&self.tx_lock, &self.tx_lock,
(self.A.clone(), sig_a), (self.A, sig_a),
(self.b.public(), sig_b), (self.b.public(), sig_b),
)?; )?;
@ -668,7 +652,7 @@ impl State3 {
let signed_tx_refund = tx_refund.add_signatures( let signed_tx_refund = tx_refund.add_signatures(
&tx_cancel.clone(), &tx_cancel.clone(),
(self.A.clone(), sig_a), (self.A, sig_a),
(self.b.public(), sig_b), (self.b.public(), sig_b),
)?; )?;
@ -707,26 +691,22 @@ pub struct State4 {
impl State4 { impl State4 {
pub fn next_message(&self) -> Message3 { pub fn next_message(&self) -> Message3 {
let tx_redeem = bitcoin::TxRedeem::new(&self.tx_lock, &self.redeem_address); let tx_redeem = bitcoin::TxRedeem::new(&self.tx_lock, &self.redeem_address);
let tx_redeem_encsig = self.b.encsign(self.S_a_bitcoin.clone(), tx_redeem.digest()); let tx_redeem_encsig = self.b.encsign(self.S_a_bitcoin, tx_redeem.digest());
Message3 { tx_redeem_encsig } Message3 { tx_redeem_encsig }
} }
pub fn tx_redeem_encsig(&self) -> EncryptedSignature { pub fn tx_redeem_encsig(&self) -> EncryptedSignature {
let tx_redeem = bitcoin::TxRedeem::new(&self.tx_lock, &self.redeem_address); let tx_redeem = bitcoin::TxRedeem::new(&self.tx_lock, &self.redeem_address);
self.b.encsign(self.S_a_bitcoin.clone(), tx_redeem.digest()) self.b.encsign(self.S_a_bitcoin, tx_redeem.digest())
} }
pub async fn check_for_tx_cancel<W>(&self, bitcoin_wallet: &W) -> Result<Transaction> pub async fn check_for_tx_cancel<W>(&self, bitcoin_wallet: &W) -> Result<Transaction>
where where
W: GetRawTransaction, W: GetRawTransaction,
{ {
let tx_cancel = bitcoin::TxCancel::new( let tx_cancel =
&self.tx_lock, bitcoin::TxCancel::new(&self.tx_lock, self.refund_timelock, self.A, self.b.public());
self.refund_timelock,
self.A.clone(),
self.b.public(),
);
// todo: check if this is correct // todo: check if this is correct
let sig_a = self.tx_cancel_sig_a.clone(); let sig_a = self.tx_cancel_sig_a.clone();
@ -734,11 +714,7 @@ impl State4 {
let tx_cancel = tx_cancel let tx_cancel = tx_cancel
.clone() .clone()
.add_signatures( .add_signatures(&self.tx_lock, (self.A, sig_a), (self.b.public(), sig_b))
&self.tx_lock,
(self.A.clone(), sig_a),
(self.b.public(), sig_b),
)
.expect( .expect(
"sig_{a,b} to be valid signatures for "sig_{a,b} to be valid signatures for
tx_cancel", tx_cancel",
@ -753,12 +729,8 @@ impl State4 {
where where
W: BroadcastSignedTransaction, W: BroadcastSignedTransaction,
{ {
let tx_cancel = bitcoin::TxCancel::new( let tx_cancel =
&self.tx_lock, bitcoin::TxCancel::new(&self.tx_lock, self.refund_timelock, self.A, self.b.public());
self.refund_timelock,
self.A.clone(),
self.b.public(),
);
// todo: check if this is correct // todo: check if this is correct
let sig_a = self.tx_cancel_sig_a.clone(); let sig_a = self.tx_cancel_sig_a.clone();
@ -766,11 +738,7 @@ impl State4 {
let tx_cancel = tx_cancel let tx_cancel = tx_cancel
.clone() .clone()
.add_signatures( .add_signatures(&self.tx_lock, (self.A, sig_a), (self.b.public(), sig_b))
&self.tx_lock,
(self.A.clone(), sig_a),
(self.b.public(), sig_b),
)
.expect( .expect(
"sig_{a,b} to be valid signatures for "sig_{a,b} to be valid signatures for
tx_cancel", tx_cancel",
@ -787,7 +755,7 @@ impl State4 {
W: WatchForRawTransaction, W: WatchForRawTransaction,
{ {
let tx_redeem = bitcoin::TxRedeem::new(&self.tx_lock, &self.redeem_address); let tx_redeem = bitcoin::TxRedeem::new(&self.tx_lock, &self.redeem_address);
let tx_redeem_encsig = self.b.encsign(self.S_a_bitcoin.clone(), tx_redeem.digest()); let tx_redeem_encsig = self.b.encsign(self.S_a_bitcoin, tx_redeem.digest());
let tx_redeem_candidate = bitcoin_wallet let tx_redeem_candidate = bitcoin_wallet
.watch_for_raw_transaction(tx_redeem.txid()) .watch_for_raw_transaction(tx_redeem.txid())
@ -795,16 +763,16 @@ impl State4 {
let tx_redeem_sig = let tx_redeem_sig =
tx_redeem.extract_signature_by_key(tx_redeem_candidate, self.b.public())?; tx_redeem.extract_signature_by_key(tx_redeem_candidate, self.b.public())?;
let s_a = bitcoin::recover(self.S_a_bitcoin.clone(), tx_redeem_sig, tx_redeem_encsig)?; let s_a = bitcoin::recover(self.S_a_bitcoin, tx_redeem_sig, tx_redeem_encsig)?;
let s_a = monero::private_key_from_secp256k1_scalar(s_a.into()); let s_a = monero::private_key_from_secp256k1_scalar(s_a.into());
Ok(State5 { Ok(State5 {
A: self.A.clone(), A: self.A,
b: self.b.clone(), b: self.b.clone(),
s_a, s_a,
s_b: self.s_b, s_b: self.s_b,
S_a_monero: self.S_a_monero, S_a_monero: self.S_a_monero,
S_a_bitcoin: self.S_a_bitcoin.clone(), S_a_bitcoin: self.S_a_bitcoin,
v: self.v, v: self.v,
btc: self.btc, btc: self.btc,
xmr: self.xmr, xmr: self.xmr,