Git-Mirrors/xmr-btc-swap
1
0
Fork 0
mirror of https://github.com/comit-network/xmr-btc-swap.git synced 2025-08-05 21:14:32 -04:00
Code Issues Projects Releases Packages Wiki Activity

Save and recover protocol state from disk

Browse source 
NOTE: This implementation saves secrets to disk! It is not
secure.

The storage API allows the caller to atomically record the state
of the protocol. The user can retrieve this recorded state and
re-commence the protocol from that point. The state is recorded
using a hard coded key, causing it to overwrite the previously
recorded state. This limitation means that this recovery
mechanism should not be used in a program that simultaneously
manages the execution of multiple swaps.

An e2e test was added to show how to save, recover and resume
protocol execution. This logic could also be integrated into the
run_until functions to automate saving but was not included at
this stage as protocol execution is currently under development.

Serialisation and deserialisation was implemented on the states
to allow the to be stored using the database. Currently the
secret's are also being stored to disk but should be recovered
from a seed or wallets.
This commit is contained in:
rishflab 2020-10-14 09:32:25 +11:00
parent ea064c95b4
commit 39afb4196b
11 changed files with 571 additions and 29 deletions
Download patch file Download diff file Expand all files Collapse all files

37
xmr-btc/src/alice.rs
View file

@ -3,6 +3,7 @@ use crate::{
bitcoin::{BroadcastSignedTransaction, WatchForRawTransaction},
bob, monero,
monero::{CreateWalletForOutput, Transfer},
serde::{bitcoin_amount, cross_curve_dleq_scalar, ecdsa_fun_signature},
transport::{ReceiveMessage, SendMessage},
};
use anyhow::{anyhow, Result};
@ -11,6 +12,7 @@ use ecdsa_fun::{
nonce::Deterministic,
};
use rand::{CryptoRng, RngCore};
use serde::{Deserialize, Serialize};
use sha2::Sha256;
use std::convert::{TryFrom, TryInto};
@ -129,11 +131,13 @@ impl State {
}
}
#[derive(Debug)]
#[derive(Debug, Deserialize, Serialize)]
pub struct State0 {
a: bitcoin::SecretKey,
#[serde(with = "cross_curve_dleq_scalar")]
s_a: cross_curve_dleq::Scalar,
v_a: monero::PrivateViewKey,
#[serde(with = "bitcoin_amount")]
btc: bitcoin::Amount,
xmr: monero::Amount,
refund_timelock: u32,
@ -215,14 +219,16 @@ impl State0 {
}
}
#[derive(Debug)]
#[derive(Debug, Deserialize, Serialize)]
pub struct State1 {
a: bitcoin::SecretKey,
B: bitcoin::PublicKey,
#[serde(with = "cross_curve_dleq_scalar")]
s_a: cross_curve_dleq::Scalar,
S_b_monero: monero::PublicKey,
S_b_bitcoin: bitcoin::PublicKey,
v: monero::PrivateViewKey,
#[serde(with = "bitcoin_amount")]
btc: bitcoin::Amount,
xmr: monero::Amount,
refund_timelock: u32,
@ -253,14 +259,16 @@ impl State1 {
}
}
#[derive(Debug)]
#[derive(Debug, Deserialize, Serialize)]
pub struct State2 {
a: bitcoin::SecretKey,
B: bitcoin::PublicKey,
#[serde(with = "cross_curve_dleq_scalar")]
s_a: cross_curve_dleq::Scalar,
S_b_monero: monero::PublicKey,
S_b_bitcoin: bitcoin::PublicKey,
v: monero::PrivateViewKey,
#[serde(with = "bitcoin_amount")]
btc: bitcoin::Amount,
xmr: monero::Amount,
refund_timelock: u32,
@ -328,14 +336,16 @@ impl State2 {
}
}
#[derive(Debug)]
#[derive(Debug, Deserialize, Serialize)]
pub struct State3 {
a: bitcoin::SecretKey,
B: bitcoin::PublicKey,
#[serde(with = "cross_curve_dleq_scalar")]
s_a: cross_curve_dleq::Scalar,
S_b_monero: monero::PublicKey,
S_b_bitcoin: bitcoin::PublicKey,
v: monero::PrivateViewKey,
#[serde(with = "bitcoin_amount")]
btc: bitcoin::Amount,
xmr: monero::Amount,
refund_timelock: u32,
@ -344,7 +354,9 @@ pub struct State3 {
redeem_address: bitcoin::Address,
punish_address: bitcoin::Address,
tx_lock: bitcoin::TxLock,
#[serde(with = "ecdsa_fun_signature")]
tx_punish_sig_bob: bitcoin::Signature,
#[serde(with = "ecdsa_fun_signature")]
tx_cancel_sig_bob: bitcoin::Signature,
}
@ -381,14 +393,16 @@ impl State3 {
}
}
#[derive(Debug)]
#[derive(Debug, Deserialize, Serialize)]
pub struct State4 {
a: bitcoin::SecretKey,
B: bitcoin::PublicKey,
#[serde(with = "cross_curve_dleq_scalar")]
s_a: cross_curve_dleq::Scalar,
S_b_monero: monero::PublicKey,
S_b_bitcoin: bitcoin::PublicKey,
v: monero::PrivateViewKey,
#[serde(with = "bitcoin_amount")]
btc: bitcoin::Amount,
xmr: monero::Amount,
refund_timelock: u32,
@ -397,7 +411,9 @@ pub struct State4 {
redeem_address: bitcoin::Address,
punish_address: bitcoin::Address,
tx_lock: bitcoin::TxLock,
#[serde(with = "ecdsa_fun_signature")]
tx_punish_sig_bob: bitcoin::Signature,
#[serde(with = "ecdsa_fun_signature")]
tx_cancel_sig_bob: bitcoin::Signature,
}
@ -484,14 +500,16 @@ impl State4 {
}
}
#[derive(Debug)]
#[derive(Debug, Deserialize, Serialize)]
pub struct State5 {
a: bitcoin::SecretKey,
B: bitcoin::PublicKey,
#[serde(with = "cross_curve_dleq_scalar")]
s_a: cross_curve_dleq::Scalar,
S_b_monero: monero::PublicKey,
S_b_bitcoin: bitcoin::PublicKey,
v: monero::PrivateViewKey,
#[serde(with = "bitcoin_amount")]
btc: bitcoin::Amount,
xmr: monero::Amount,
refund_timelock: u32,
@ -501,7 +519,9 @@ pub struct State5 {
punish_address: bitcoin::Address,
tx_lock: bitcoin::TxLock,
tx_lock_proof: monero::TransferProof,
#[serde(with = "ecdsa_fun_signature")]
tx_punish_sig_bob: bitcoin::Signature,
#[serde(with = "ecdsa_fun_signature")]
tx_cancel_sig_bob: bitcoin::Signature,
lock_xmr_fee: monero::Amount,
}
@ -575,14 +595,16 @@ impl State5 {
}
}
#[derive(Debug)]
#[derive(Debug, Deserialize, Serialize)]
pub struct State6 {
a: bitcoin::SecretKey,
B: bitcoin::PublicKey,
#[serde(with = "cross_curve_dleq_scalar")]
s_a: cross_curve_dleq::Scalar,
S_b_monero: monero::PublicKey,
S_b_bitcoin: bitcoin::PublicKey,
v: monero::PrivateViewKey,
#[serde(with = "bitcoin_amount")]
btc: bitcoin::Amount,
xmr: monero::Amount,
refund_timelock: u32,
@ -591,6 +613,7 @@ pub struct State6 {
redeem_address: bitcoin::Address,
punish_address: bitcoin::Address,
tx_lock: bitcoin::TxLock,
#[serde(with = "ecdsa_fun_signature")]
tx_punish_sig_bob: bitcoin::Signature,
tx_redeem_encsig: EncryptedSignature,
lock_xmr_fee: monero::Amount,

5
xmr-btc/src/bitcoin.rs
View file

@ -21,6 +21,7 @@ use ecdsa_fun::{
pub use ecdsa_fun::{adaptor::EncryptedSignature, Signature};
use miniscript::{Descriptor, Segwitv0};
use rand::{CryptoRng, RngCore};
use serde::{Deserialize, Serialize};
use sha2::Sha256;
use std::str::FromStr;
@ -28,7 +29,7 @@ pub use crate::bitcoin::transactions::{TxCancel, TxLock, TxPunish, TxRedeem, TxR
pub const TX_FEE: u64 = 10_000;
#[derive(Debug, Clone)]
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
pub struct SecretKey {
inner: Scalar,
public: Point,
@ -83,7 +84,7 @@ impl SecretKey {
}
}
#[derive(Debug, Clone)]
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct PublicKey(Point);
impl From<PublicKey> for Point<Jacobian> {

3
xmr-btc/src/bitcoin/transactions.rs
View file

@ -8,9 +8,10 @@ use bitcoin::{
};
use ecdsa_fun::Signature;
use miniscript::Descriptor;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
#[derive(Debug, Clone)]
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct TxLock {
inner: Transaction,
output_descriptor: Descriptor<::bitcoin::PublicKey>,

27
xmr-btc/src/bob.rs
View file

@ -6,6 +6,7 @@ use crate::{
},
monero,
monero::{CheckTransfer, CreateWalletForOutput},
serde::{bitcoin_amount, cross_curve_dleq_scalar, monero_private_key},
transport::{ReceiveMessage, SendMessage},
};
use anyhow::{anyhow, Result};
@ -15,6 +16,7 @@ use ecdsa_fun::{
Signature,
};
use rand::{CryptoRng, RngCore};
use serde::{Deserialize, Serialize};
use sha2::Sha256;
use std::convert::{TryFrom, TryInto};
@ -102,11 +104,13 @@ impl_from_child_enum!(State3, State);
impl_from_child_enum!(State4, State);
impl_from_child_enum!(State5, State);
#[derive(Debug)]
#[derive(Debug, Deserialize, Serialize)]
pub struct State0 {
b: bitcoin::SecretKey,
#[serde(with = "cross_curve_dleq_scalar")]
s_b: cross_curve_dleq::Scalar,
v_b: monero::PrivateViewKey,
#[serde(with = "bitcoin_amount")]
btc: bitcoin::Amount,
xmr: monero::Amount,
refund_timelock: u32,
@ -190,14 +194,16 @@ impl State0 {
}
}
#[derive(Debug)]
#[derive(Debug, Deserialize, Serialize)]
pub struct State1 {
A: bitcoin::PublicKey,
b: bitcoin::SecretKey,
#[serde(with = "cross_curve_dleq_scalar")]
s_b: cross_curve_dleq::Scalar,
S_a_monero: monero::PublicKey,
S_a_bitcoin: bitcoin::PublicKey,
v: monero::PrivateViewKey,
#[serde(with = "bitcoin_amount")]
btc: bitcoin::Amount,
xmr: monero::Amount,
refund_timelock: u32,
@ -253,14 +259,16 @@ impl State1 {
}
}
#[derive(Debug)]
#[derive(Debug, Deserialize, Serialize)]
pub struct State2 {
A: bitcoin::PublicKey,
b: bitcoin::SecretKey,
#[serde(with = "cross_curve_dleq_scalar")]
s_b: cross_curve_dleq::Scalar,
S_a_monero: monero::PublicKey,
S_a_bitcoin: bitcoin::PublicKey,
v: monero::PrivateViewKey,
#[serde(with = "bitcoin_amount")]
btc: bitcoin::Amount,
xmr: monero::Amount,
refund_timelock: u32,
@ -324,14 +332,16 @@ impl State2 {
}
}
#[derive(Debug)]
#[derive(Debug, Serialize, Deserialize)]
pub struct State3 {
A: bitcoin::PublicKey,
b: bitcoin::SecretKey,
#[serde(with = "cross_curve_dleq_scalar")]
s_b: cross_curve_dleq::Scalar,
S_a_monero: monero::PublicKey,
S_a_bitcoin: bitcoin::PublicKey,
v: monero::PrivateViewKey,
#[serde(with = "bitcoin_amount")]
btc: bitcoin::Amount,
xmr: monero::Amount,
refund_timelock: u32,
@ -429,14 +439,16 @@ impl State3 {
}
}
#[derive(Debug)]
#[derive(Debug, Deserialize, Serialize)]
pub struct State4 {
A: bitcoin::PublicKey,
b: bitcoin::SecretKey,
#[serde(with = "cross_curve_dleq_scalar")]
s_b: cross_curve_dleq::Scalar,
S_a_monero: monero::PublicKey,
S_a_bitcoin: bitcoin::PublicKey,
v: monero::PrivateViewKey,
#[serde(with = "bitcoin_amount")]
btc: bitcoin::Amount,
xmr: monero::Amount,
refund_timelock: u32,
@ -496,15 +508,18 @@ impl State4 {
}
}
#[derive(Debug)]
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct State5 {
A: bitcoin::PublicKey,
b: bitcoin::SecretKey,
#[serde(with = "monero_private_key")]
s_a: monero::PrivateKey,
#[serde(with = "cross_curve_dleq_scalar")]
s_b: cross_curve_dleq::Scalar,
S_a_monero: monero::PublicKey,
S_a_bitcoin: bitcoin::PublicKey,
v: monero::PrivateViewKey,
#[serde(with = "bitcoin_amount")]
btc: bitcoin::Amount,
xmr: monero::Amount,
refund_timelock: u32,

1
xmr-btc/src/lib.rs
View file

@ -49,4 +49,5 @@ pub mod alice;
pub mod bitcoin;
pub mod bob;
pub mod monero;
pub mod serde;
pub mod transport;

13
xmr-btc/src/monero.rs
View file

@ -1,8 +1,10 @@
use crate::serde::monero_private_key;
use anyhow::Result;
use async_trait::async_trait;
pub use curve25519_dalek::scalar::Scalar;
pub use monero::{Address, PrivateKey, PublicKey};
use rand::{CryptoRng, RngCore};
use serde::{Deserialize, Serialize};
use std::ops::Add;
pub fn random_private_key<R: RngCore + CryptoRng>(rng: &mut R) -> PrivateKey {
@ -11,8 +13,8 @@ pub fn random_private_key<R: RngCore + CryptoRng>(rng: &mut R) -> PrivateKey {
PrivateKey::from_scalar(scalar)
}
#[derive(Clone, Copy, Debug)]
pub struct PrivateViewKey(PrivateKey);
#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq)]
pub struct PrivateViewKey(#[serde(with = "monero_private_key")] PrivateKey);
impl PrivateViewKey {
pub fn new_random<R: RngCore + CryptoRng>(rng: &mut R) -> Self {
@ -50,7 +52,7 @@ impl From<PublicViewKey> for PublicKey {
#[derive(Clone, Copy, Debug)]
pub struct PublicViewKey(PublicKey);
#[derive(Debug, Copy, Clone)]
#[derive(Debug, Copy, Clone, Deserialize, Serialize, PartialEq)]
pub struct Amount(u64);
impl Amount {
@ -72,9 +74,10 @@ impl From<Amount> for u64 {
}
}
#[derive(Clone, Debug)]
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct TransferProof {
tx_hash: TxHash,
#[serde(with = "monero_private_key")]
tx_key: PrivateKey,
}
@ -91,7 +94,7 @@ impl TransferProof {
}
// TODO: add constructor/ change String to fixed length byte array
#[derive(Clone, Debug)]
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct TxHash(pub String);
impl From<TxHash> for String {

210
xmr-btc/src/serde.rs Normal file
View file

@ -0,0 +1,210 @@
pub mod ecdsa_fun_signature {
use serde::{de, de::Visitor, Deserializer, Serializer};
use std::{convert::TryFrom, fmt};
struct Bytes64Visitor;
impl<'de> Visitor<'de> for Bytes64Visitor {
type Value = ecdsa_fun::Signature;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(formatter, "a string containing 64 bytes")
}
fn visit_bytes<E>(self, s: &[u8]) -> Result<Self::Value, E>
where
E: de::Error,
{
if let Ok(value) = <[u8; 64]>::try_from(s) {
let sig = ecdsa_fun::Signature::from_bytes(value)
.expect("bytes represent an integer greater than or equal to the curve order");
Ok(sig)
} else {
Err(de::Error::invalid_length(s.len(), &self))
}
}
}
pub fn serialize<S>(x: &ecdsa_fun::Signature, s: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
s.serialize_bytes(&x.to_bytes())
}
pub fn deserialize<'de, D>(
deserializer: D,
) -> Result<ecdsa_fun::Signature, <D as Deserializer<'de>>::Error>
where
D: Deserializer<'de>,
{
let sig = deserializer.deserialize_bytes(Bytes64Visitor)?;
Ok(sig)
}
}
pub mod cross_curve_dleq_scalar {
use serde::{de, de::Visitor, Deserializer, Serializer};
use std::{convert::TryFrom, fmt};
struct Bytes32Visitor;
impl<'de> Visitor<'de> for Bytes32Visitor {
type Value = cross_curve_dleq::Scalar;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(formatter, "a string containing 32 bytes")
}
fn visit_bytes<E>(self, s: &[u8]) -> Result<Self::Value, E>
where
E: de::Error,
{
if let Ok(value) = <[u8; 32]>::try_from(s) {
Ok(cross_curve_dleq::Scalar::from(value))
} else {
Err(de::Error::invalid_length(s.len(), &self))
}
}
}
pub fn serialize<S>(x: &cross_curve_dleq::Scalar, s: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
// Serialise as ed25519 because the inner bytes are private
// TODO: Open PR in cross_curve_dleq to allow accessing the inner bytes
s.serialize_bytes(&x.into_ed25519().to_bytes())
}
pub fn deserialize<'de, D>(
deserializer: D,
) -> Result<cross_curve_dleq::Scalar, <D as Deserializer<'de>>::Error>
where
D: Deserializer<'de>,
{
let dleq = deserializer.deserialize_bytes(Bytes32Visitor)?;
Ok(dleq)
}
}
pub mod monero_private_key {
use serde::{de, de::Visitor, Deserializer, Serializer};
use std::fmt;
struct BytesVisitor;
impl<'de> Visitor<'de> for BytesVisitor {
type Value = monero::PrivateKey;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(formatter, "a string containing 32 bytes")
}
fn visit_bytes<E>(self, s: &[u8]) -> Result<Self::Value, E>
where
E: de::Error,
{
if let Ok(key) = monero::PrivateKey::from_slice(s) {
Ok(key)
} else {
Err(de::Error::invalid_length(s.len(), &self))
}
}
}
pub fn serialize<S>(x: &monero::PrivateKey, s: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
s.serialize_bytes(x.as_bytes())
}
pub fn deserialize<'de, D>(
deserializer: D,
) -> Result<monero::PrivateKey, <D as Deserializer<'de>>::Error>
where
D: Deserializer<'de>,
{
let key = deserializer.deserialize_bytes(BytesVisitor)?;
Ok(key)
}
}
pub mod bitcoin_amount {
use serde::{Deserialize, Deserializer, Serializer};
pub fn serialize<S>(value: &bitcoin::Amount, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.serialize_u64(value.as_sat())
}
pub fn deserialize<'de, D>(
deserializer: D,
) -> Result<bitcoin::Amount, <D as Deserializer<'de>>::Error>
where
D: Deserializer<'de>,
{
let value = u64::deserialize(deserializer)?;
let amount = bitcoin::Amount::from_sat(value);
Ok(amount)
}
}
#[cfg(test)]
mod tests {
use super::*;
use ::bitcoin::SigHash;
use curve25519_dalek::scalar::Scalar;
use rand::rngs::OsRng;
use serde::{Deserialize, Serialize};
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct CrossCurveDleqScalar(
#[serde(with = "cross_curve_dleq_scalar")] cross_curve_dleq::Scalar,
);
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct ECDSAFunSignature(#[serde(with = "ecdsa_fun_signature")] ecdsa_fun::Signature);
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct MoneroPrivateKey(#[serde(with = "monero_private_key")] crate::monero::PrivateKey);
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct BitcoinAmount(#[serde(with = "bitcoin_amount")] ::bitcoin::Amount);
#[test]
fn serde_cross_curv_dleq_scalar() {
let scalar = CrossCurveDleqScalar(cross_curve_dleq::Scalar::random(&mut OsRng));
let encoded = serde_cbor::to_vec(&scalar).unwrap();
let decoded: CrossCurveDleqScalar = serde_cbor::from_slice(&encoded).unwrap();
assert_eq!(scalar, decoded);
}
#[test]
fn serde_ecdsa_fun_sig() {
let secret_key = crate::bitcoin::SecretKey::new_random(&mut OsRng);
let sig = ECDSAFunSignature(secret_key.sign(SigHash::default()));
let encoded = serde_cbor::to_vec(&sig).unwrap();
let decoded: ECDSAFunSignature = serde_cbor::from_slice(&encoded).unwrap();
assert_eq!(sig, decoded);
}
#[test]
fn serde_monero_private_key() {
let key = MoneroPrivateKey(monero::PrivateKey::from_scalar(Scalar::random(&mut OsRng)));
let encoded = serde_cbor::to_vec(&key).unwrap();
let decoded: MoneroPrivateKey = serde_cbor::from_slice(&encoded).unwrap();
assert_eq!(key, decoded);
}
#[test]
fn serde_bitcoin_amount() {
let amount = BitcoinAmount(::bitcoin::Amount::from_sat(100));
let encoded = serde_cbor::to_vec(&amount).unwrap();
let decoded: BitcoinAmount = serde_cbor::from_slice(&encoded).unwrap();
assert_eq!(amount, decoded);
}
}