Browse Source
Cfd protocol got moved into a separate repository. All references of `cfd_protocol` were renamed to `maia`. Patch cargo.toml with a fixed git revision until it gets a public release.rollover-test
Mariusz Klochowicz
3 years ago
27 changed files with 47 additions and 3191 deletions
@ -1,8 +1,9 @@ |
|||
[workspace] |
|||
members = ["cfd_protocol", "daemon", "xtra_productivity"] |
|||
members = ["daemon", "xtra_productivity"] |
|||
resolver = "2" |
|||
|
|||
[patch.crates-io] |
|||
rocket = { git = "https://github.com/SergioBenitez/Rocket" } # Need to patch rocket dependency of `rocket_basicauth` until there is an official release. |
|||
xtra = { git = "https://github.com/Restioson/xtra" } # Latest master has crucial patches. |
|||
secp256k1-zkp = { git = "https://github.com/ElementsProject/rust-secp256k1-zkp" } # Latest master has crucial patches. |
|||
maia = { git = "https://github.com/comit-network/maia", rev = "70fc548da0fe4f34478fb34ec437fa9a434c7ee3" } |
|||
|
|||
@ -1,17 +0,0 @@ |
|||
[package] |
|||
name = "cfd_protocol" |
|||
version = "0.1.0" |
|||
edition = "2018" |
|||
|
|||
[dependencies] |
|||
anyhow = "1" |
|||
bdk = { version = "0.13", default-features = false } |
|||
bit-vec = "0.6" |
|||
itertools = "0.10" |
|||
rand = "0.6" |
|||
secp256k1-zkp = { version = "0.4", features = ["bitcoin_hashes", "global-context", "serde"] } |
|||
thiserror = "1" |
|||
|
|||
[dev-dependencies] |
|||
bitcoin = { version = "0.27", features = ["rand", "bitcoinconsensus"] } |
|||
proptest = { version = "1", default-features = false, features = ["std"] } |
|||
@ -1,157 +0,0 @@ |
|||
use bit_vec::BitVec; |
|||
use std::fmt::Display; |
|||
use std::num::NonZeroU8; |
|||
use std::ops::RangeInclusive; |
|||
|
|||
mod digit_decomposition; |
|||
|
|||
/// Maximum supported BTC price in whole USD.
|
|||
pub const MAX_PRICE_DEC: u64 = (BASE as u64).pow(MAX_DIGITS as u32) - 1; |
|||
|
|||
/// Maximum number of binary digits for BTC price in whole USD.
|
|||
const MAX_DIGITS: usize = 20; |
|||
|
|||
const BASE: usize = 2; |
|||
|
|||
/// Binary representation of a price interval.
|
|||
#[derive(Clone, Debug, PartialEq)] |
|||
pub struct Digits(BitVec); |
|||
|
|||
impl Digits { |
|||
pub fn new(range: RangeInclusive<u64>) -> Result<Vec<Self>, Error> { |
|||
let (start, end) = range.into_inner(); |
|||
if start > MAX_PRICE_DEC || end > MAX_PRICE_DEC { |
|||
return Err(Error::RangeOverMax); |
|||
} |
|||
|
|||
if start > end { |
|||
return Err(Error::DecreasingRange); |
|||
} |
|||
|
|||
let digits = digit_decomposition::group_by_ignoring_digits( |
|||
start as usize, |
|||
end as usize, |
|||
BASE, |
|||
MAX_DIGITS, |
|||
) |
|||
.iter() |
|||
.map(|digits| { |
|||
let digits = digits.iter().map(|n| *n != 0).collect::<BitVec>(); |
|||
Digits(digits) |
|||
}) |
|||
.collect(); |
|||
|
|||
Ok(digits) |
|||
} |
|||
|
|||
/// Calculate the range of prices expressed by these digits.
|
|||
///
|
|||
/// With the resulting range one can assess wether a particular
|
|||
/// price corresponds to the described interval.
|
|||
pub fn range(&self) -> RangeInclusive<u64> { |
|||
let missing_bits = MAX_DIGITS - self.0.len(); |
|||
|
|||
let mut bits = self.0.clone(); |
|||
bits.append(&mut BitVec::from_elem(missing_bits, false)); |
|||
let start = bits.as_u64(); |
|||
|
|||
let mut bits = self.0.clone(); |
|||
bits.append(&mut BitVec::from_elem(missing_bits, true)); |
|||
let end = bits.as_u64(); |
|||
|
|||
start..=end |
|||
} |
|||
|
|||
/// Map each bit to its index in the set {0, 1}, starting at 1.
|
|||
pub fn to_indices(&self) -> Vec<NonZeroU8> { |
|||
self.0 |
|||
.iter() |
|||
.map(|bit| NonZeroU8::new(if bit { 2u8 } else { 1u8 }).expect("1 and 2 are non-zero")) |
|||
.collect() |
|||
} |
|||
|
|||
pub fn len(&self) -> usize { |
|||
self.0.len() |
|||
} |
|||
|
|||
pub fn is_empty(&self) -> bool { |
|||
self.0.is_empty() |
|||
} |
|||
} |
|||
|
|||
#[derive(thiserror::Error, Debug)] |
|||
pub enum Error { |
|||
#[error("Interval would generate values over maximum price of {MAX_PRICE_DEC}.")] |
|||
RangeOverMax, |
|||
#[error("Invalid decreasing interval.")] |
|||
DecreasingRange, |
|||
} |
|||
|
|||
impl Display for Digits { |
|||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { |
|||
self.0 |
|||
.iter() |
|||
.try_for_each(|digit| write!(f, "{}", digit as u8))?; |
|||
|
|||
Ok(()) |
|||
} |
|||
} |
|||
|
|||
trait BitVecExt { |
|||
fn as_u64(&self) -> u64; |
|||
} |
|||
|
|||
impl BitVecExt for BitVec { |
|||
fn as_u64(&self) -> u64 { |
|||
let len = self.len(); |
|||
|
|||
self.iter().enumerate().fold(0, |acc, (i, x)| { |
|||
acc + ((x as u64) * (BASE.pow((len - i - 1) as u32) as u64)) |
|||
}) |
|||
} |
|||
} |
|||
|
|||
#[cfg(test)] |
|||
mod tests { |
|||
use super::*; |
|||
|
|||
use anyhow::Result; |
|||
use proptest::prelude::*; |
|||
|
|||
#[derive(Debug, Clone)] |
|||
struct Interval(RangeInclusive<u64>); |
|||
|
|||
impl Interval { |
|||
fn new(range: RangeInclusive<u64>) -> Self { |
|||
Self(range) |
|||
} |
|||
|
|||
fn to_digits(&self) -> Result<Vec<Digits>> { |
|||
let digits = Digits::new(self.0.clone())?; |
|||
|
|||
Ok(digits) |
|||
} |
|||
} |
|||
|
|||
impl PartialEq<Vec<Digits>> for Interval { |
|||
fn eq(&self, other: &Vec<Digits>) -> bool { |
|||
let sub_intervals = other.iter().flat_map(|i| i.range()); |
|||
sub_intervals.eq(self.0.clone()) |
|||
} |
|||
} |
|||
|
|||
prop_compose! { |
|||
fn interval()(x in 0u64..=MAX_PRICE_DEC, y in 0u64..=MAX_PRICE_DEC) -> Interval { |
|||
let (start, end) = if x < y { (x, y) } else { (y, x) }; |
|||
|
|||
Interval::new(start..=end) |
|||
} |
|||
} |
|||
|
|||
proptest! { |
|||
#[test] |
|||
fn interval_equal_to_sum_of_sub_intervals_described_by_digits(interval in interval()) { |
|||
prop_assert!(interval == interval.to_digits().unwrap()) |
|||
} |
|||
} |
|||
} |
|||
@ -1,459 +0,0 @@ |
|||
//! Utility functions to decompose numeric outcome values
|
|||
//!
|
|||
//! This code has been lifted from:
|
|||
//! <https://github.com/p2pderivatives/rust-dlc/blob/chore%2Ffactor-out-dlc-trie/dlc-trie/src/digit_decomposition.rs>
|
|||
|
|||
/// Describes an interval that starts at `prefix || start` and terminates at `prefix || end`.
|
|||
struct PrefixInterval { |
|||
/// The prefix common to all numbers within the interval.
|
|||
prefix: Vec<usize>, |
|||
/// The suffix of the first number in the interval.
|
|||
start: Vec<usize>, |
|||
/// The suffix of the last number in the interval.
|
|||
end: Vec<usize>, |
|||
} |
|||
|
|||
/// Decompose a numeric value into digits in the specified base. If the decomposed
|
|||
/// value contains less than `nb_digits`, zeroes will be prepended to reach `nb_digits`
|
|||
/// size.
|
|||
fn decompose_value(mut value: usize, base: usize, nb_digits: usize) -> Vec<usize> { |
|||
let mut res = Vec::new(); |
|||
|
|||
while value > 0 { |
|||
res.push(value % base); |
|||
value = ((value as f64) / (base as f64)).floor() as usize; |
|||
} |
|||
|
|||
while res.len() < nb_digits { |
|||
res.push(0); |
|||
} |
|||
|
|||
assert_eq!(nb_digits, res.len()); |
|||
|
|||
res.into_iter().rev().collect() |
|||
} |
|||
|
|||
/// Returns the interval [start, end] as a `PrefixInterval`, which will contain
|
|||
/// the common prefix to all numbers in the interval as well as the start and end
|
|||
/// suffixes decomposed in the specified base, and zero padded to `nb_digits` if
|
|||
/// necessary.
|
|||
fn separate_prefix(start: usize, end: usize, base: usize, nb_digits: usize) -> PrefixInterval { |
|||
let start_digits = decompose_value(start, base, nb_digits); |
|||
let end_digits = decompose_value(end, base, nb_digits); |
|||
let mut prefix = Vec::new(); |
|||
|
|||
let mut i = 0; |
|||
while i < nb_digits && start_digits[i] == end_digits[i] { |
|||
prefix.push(start_digits[i]); |
|||
i += 1; |
|||
} |
|||
let start = start_digits.into_iter().skip(prefix.len()).collect(); |
|||
|
|||
let end = end_digits.into_iter().skip(prefix.len()).collect(); |
|||
|
|||
PrefixInterval { prefix, start, end } |
|||
} |
|||
|
|||
/// Removes the trailing digits from `digits` that are equal to `num`.
|
|||
fn remove_tail_if_equal(mut digits: Vec<usize>, num: usize) -> Vec<usize> { |
|||
let mut i = digits.len(); |
|||
while i > 1 && digits[i - 1] == num { |
|||
i -= 1; |
|||
} |
|||
digits.truncate(i); |
|||
digits |
|||
} |
|||
|
|||
/// Compute the groupings for the end of the interval.
|
|||
fn back_groupings(digits: Vec<usize>, base: usize) -> Vec<Vec<usize>> { |
|||
let digits = remove_tail_if_equal(digits, base - 1); |
|||
if digits.is_empty() { |
|||
return vec![vec![base - 1]]; |
|||
} |
|||
let mut prefix = vec![digits[0]]; |
|||
let mut res: Vec<Vec<usize>> = Vec::new(); |
|||
for digit in digits.iter().skip(1) { |
|||
let mut last = 0; |
|||
let digit = *digit; |
|||
while last < digit { |
|||
let mut new_res = prefix.clone(); |
|||
new_res.push(last); |
|||
res.push(new_res); |
|||
last += 1; |
|||
} |
|||
prefix.push(digit); |
|||
} |
|||
res.push(digits); |
|||
res |
|||
} |
|||
|
|||
/// Compute the groupings for the beginning of the interval.
|
|||
fn front_groupings(digits: Vec<usize>, base: usize) -> Vec<Vec<usize>> { |
|||
let digits = remove_tail_if_equal(digits, 0); |
|||
if digits.is_empty() { |
|||
return vec![vec![0]]; |
|||
} |
|||
let mut prefix = digits.clone(); |
|||
let mut res: Vec<Vec<usize>> = vec![digits.clone()]; |
|||
for digit in digits.into_iter().skip(1).rev() { |
|||
prefix.pop(); |
|||
let mut last = digit + 1; |
|||
while last < base { |
|||
let mut new_res = prefix.clone(); |
|||
new_res.push(last); |
|||
res.push(new_res); |
|||
last += 1; |
|||
} |
|||
} |
|||
|
|||
res |
|||
} |
|||
|
|||
/// Compute the groupings for the middle of the interval.
|
|||
fn middle_grouping(first_digit_start: usize, first_digit_end: usize) -> Vec<Vec<usize>> { |
|||
let mut res: Vec<Vec<usize>> = Vec::new(); |
|||
let mut first_digit_start = first_digit_start + 1; |
|||
while first_digit_start < first_digit_end { |
|||
res.push(vec![first_digit_start]); |
|||
first_digit_start += 1; |
|||
} |
|||
|
|||
res |
|||
} |
|||
|
|||
/// Returns the set of decomposed prefixes that cover the range [start, end].
|
|||
pub(crate) fn group_by_ignoring_digits( |
|||
start: usize, |
|||
end: usize, |
|||
base: usize, |
|||
num_digits: usize, |
|||
) -> Vec<Vec<usize>> { |
|||
let prefix_range = separate_prefix(start, end, base, num_digits); |
|||
let start_is_all_zeros = prefix_range.start.iter().all(|x| *x == 0); |
|||
let end_is_all_max = prefix_range.end.iter().all(|x| *x == base - 1); |
|||
|
|||
if start == end || start_is_all_zeros && end_is_all_max && !prefix_range.prefix.is_empty() { |
|||
return vec![prefix_range.prefix]; |
|||
} |
|||
let mut res: Vec<Vec<usize>> = Vec::new(); |
|||
if prefix_range.prefix.len() == num_digits - 1 { |
|||
for i in prefix_range.start[prefix_range.start.len() - 1] |
|||
..prefix_range.end[prefix_range.end.len() - 1] + 1 |
|||
{ |
|||
let mut new_res = prefix_range.prefix.clone(); |
|||
new_res.push(i); |
|||
res.push(new_res) |
|||
} |
|||
} else { |
|||
let mut front = front_groupings(prefix_range.start.clone(), base); |
|||
let mut middle = middle_grouping(prefix_range.start[0], prefix_range.end[0]); |
|||
let mut back = back_groupings(prefix_range.end.clone(), base); |
|||
res.append(&mut front); |
|||
res.append(&mut middle); |
|||
res.append(&mut back); |
|||
res = res |
|||
.into_iter() |
|||
.map(|x| { |
|||
prefix_range |
|||
.prefix |
|||
.iter() |
|||
.cloned() |
|||
.chain(x.into_iter()) |
|||
.collect() |
|||
}) |
|||
.collect(); |
|||
} |
|||
|
|||
res |
|||
} |
|||
|
|||
#[cfg(test)] |
|||
mod tests { |
|||
struct DecompositionTestCase { |
|||
composed: usize, |
|||
decomposed: Vec<usize>, |
|||
base: usize, |
|||
nb_digits: usize, |
|||
} |
|||
|
|||
struct GroupingTestCase { |
|||
start_index: usize, |
|||
end_index: usize, |
|||
base: usize, |
|||
nb_digits: usize, |
|||
expected: Vec<Vec<usize>>, |
|||
} |
|||
fn decomposition_test_cases() -> Vec<DecompositionTestCase> { |
|||
vec![ |
|||
DecompositionTestCase { |
|||
composed: 123456789, |
|||
decomposed: vec![1, 2, 3, 4, 5, 6, 7, 8, 9], |
|||
base: 10, |
|||
nb_digits: 9, |
|||
}, |
|||
DecompositionTestCase { |
|||
composed: 4321, |
|||
decomposed: vec![1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1], |
|||
base: 2, |
|||
nb_digits: 13, |
|||
}, |
|||
DecompositionTestCase { |
|||
composed: 0, |
|||
decomposed: vec![0, 0, 0, 0], |
|||
base: 8, |
|||
nb_digits: 4, |
|||
}, |
|||
DecompositionTestCase { |
|||
composed: 2, |
|||
decomposed: vec![0, 2], |
|||
base: 10, |
|||
nb_digits: 2, |
|||
}, |
|||
DecompositionTestCase { |
|||
composed: 1, |
|||
decomposed: vec![1], |
|||
base: 2, |
|||
nb_digits: 1, |
|||
}, |
|||
] |
|||
} |
|||
|
|||
fn grouping_test_cases() -> Vec<GroupingTestCase> { |
|||
vec![ |
|||
GroupingTestCase { |
|||
start_index: 123, |
|||
end_index: 123, |
|||
base: 10, |
|||
nb_digits: 3, |
|||
expected: vec![vec![1, 2, 3]], |
|||
}, |
|||
GroupingTestCase { |
|||
start_index: 171, |
|||
end_index: 210, |
|||
base: 16, |
|||
nb_digits: 2, |
|||
expected: vec![ |
|||
vec![10, 11], |
|||
vec![10, 12], |
|||
vec![10, 13], |
|||
vec![10, 14], |
|||
vec![10, 15], |
|||
vec![11], |
|||
vec![12], |
|||
vec![13, 0], |
|||
vec![13, 1], |
|||
vec![13, 2], |
|||
], |
|||
}, |
|||
GroupingTestCase { |
|||
start_index: 73899, |
|||
end_index: 73938, |
|||
base: 16, |
|||
nb_digits: 6, |
|||
expected: vec![ |
|||
vec![0, 1, 2, 0, 10, 11], |
|||
vec![0, 1, 2, 0, 10, 12], |
|||
vec![0, 1, 2, 0, 10, 13], |
|||
vec![0, 1, 2, 0, 10, 14], |
|||
vec![0, 1, 2, 0, 10, 15], |
|||
vec![0, 1, 2, 0, 11], |
|||
vec![0, 1, 2, 0, 12], |
|||
vec![0, 1, 2, 0, 13, 0], |
|||
vec![0, 1, 2, 0, 13, 1], |
|||
vec![0, 1, 2, 0, 13, 2], |
|||
], |
|||
}, |
|||
GroupingTestCase { |
|||
start_index: 1234, |
|||
end_index: 4321, |
|||
base: 10, |
|||
nb_digits: 4, |
|||
expected: vec![ |
|||
vec![1, 2, 3, 4], |
|||
vec![1, 2, 3, 5], |
|||
vec![1, 2, 3, 6], |
|||
vec![1, 2, 3, 7], |
|||
vec![1, 2, 3, 8], |
|||
vec![1, 2, 3, 9], |
|||
vec![1, 2, 4], |
|||
vec![1, 2, 5], |
|||
vec![1, 2, 6], |
|||
vec![1, 2, 7], |
|||
vec![1, 2, 8], |
|||
vec![1, 2, 9], |
|||
vec![1, 3], |
|||
vec![1, 4], |
|||
vec![1, 5], |
|||
vec![1, 6], |
|||
vec![1, 7], |
|||
vec![1, 8], |
|||
vec![1, 9], |
|||
vec![2], |
|||
vec![3], |
|||
vec![4, 0], |
|||
vec![4, 1], |
|||
vec![4, 2], |
|||
vec![4, 3, 0], |
|||
vec![4, 3, 1], |
|||
vec![4, 3, 2, 0], |
|||
vec![4, 3, 2, 1], |
|||
], |
|||
}, |
|||
GroupingTestCase { |
|||
start_index: 1201234, |
|||
end_index: 1204321, |
|||
base: 10, |
|||
nb_digits: 8, |
|||
expected: vec![ |
|||
vec![0, 1, 2, 0, 1, 2, 3, 4], |
|||
vec![0, 1, 2, 0, 1, 2, 3, 5], |
|||
vec![0, 1, 2, 0, 1, 2, 3, 6], |
|||
vec![0, 1, 2, 0, 1, 2, 3, 7], |
|||
vec![0, 1, 2, 0, 1, 2, 3, 8], |
|||
vec![0, 1, 2, 0, 1, 2, 3, 9], |
|||
vec![0, 1, 2, 0, 1, 2, 4], |
|||
vec![0, 1, 2, 0, 1, 2, 5], |
|||
vec![0, 1, 2, 0, 1, 2, 6], |
|||
vec![0, 1, 2, 0, 1, 2, 7], |
|||
vec![0, 1, 2, 0, 1, 2, 8], |
|||
vec![0, 1, 2, 0, 1, 2, 9], |
|||
vec![0, 1, 2, 0, 1, 3], |
|||
vec![0, 1, 2, 0, 1, 4], |
|||
vec![0, 1, 2, 0, 1, 5], |
|||
vec![0, 1, 2, 0, 1, 6], |
|||
vec![0, 1, 2, 0, 1, 7], |
|||
vec![0, 1, 2, 0, 1, 8], |
|||
vec![0, 1, 2, 0, 1, 9], |
|||
vec![0, 1, 2, 0, 2], |
|||
vec![0, 1, 2, 0, 3], |
|||
vec![0, 1, 2, 0, 4, 0], |
|||
vec![0, 1, 2, 0, 4, 1], |
|||
vec![0, 1, 2, 0, 4, 2], |
|||
vec![0, 1, 2, 0, 4, 3, 0], |
|||
vec![0, 1, 2, 0, 4, 3, 1], |
|||
vec![0, 1, 2, 0, 4, 3, 2, 0], |
|||
vec![0, 1, 2, 0, 4, 3, 2, 1], |
|||
], |
|||
}, |
|||
GroupingTestCase { |
|||
start_index: 2200, |
|||
end_index: 4999, |
|||
base: 10, |
|||
nb_digits: 4, |
|||
expected: vec![ |
|||
vec![2, 2], |
|||
vec![2, 3], |
|||
vec![2, 4], |
|||
vec![2, 5], |
|||
vec![2, 6], |
|||
vec![2, 7], |
|||
vec![2, 8], |
|||
vec![2, 9], |
|||
vec![3], |
|||
vec![4], |
|||
], |
|||
}, |
|||
GroupingTestCase { |
|||
start_index: 0, |
|||
end_index: 99, |
|||
base: 10, |
|||
nb_digits: 2, |
|||
expected: vec![ |
|||
vec![0], |
|||
vec![1], |
|||
vec![2], |
|||
vec![3], |
|||
vec![4], |
|||
vec![5], |
|||
vec![6], |
|||
vec![7], |
|||
vec![8], |
|||
vec![9], |
|||
], |
|||
}, |
|||
GroupingTestCase { |
|||
start_index: 100, |
|||
end_index: 199, |
|||
base: 10, |
|||
nb_digits: 3, |
|||
expected: vec![vec![1]], |
|||
}, |
|||
GroupingTestCase { |
|||
start_index: 100, |
|||
end_index: 200, |
|||
base: 10, |
|||
nb_digits: 3, |
|||
expected: vec![vec![1], vec![2, 0, 0]], |
|||
}, |
|||
GroupingTestCase { |
|||
start_index: 11, |
|||
end_index: 18, |
|||
base: 10, |
|||
nb_digits: 2, |
|||
expected: vec![ |
|||
vec![1, 1], |
|||
vec![1, 2], |
|||
vec![1, 3], |
|||
vec![1, 4], |
|||
vec![1, 5], |
|||
vec![1, 6], |
|||
vec![1, 7], |
|||
vec![1, 8], |
|||
], |
|||
}, |
|||
GroupingTestCase { |
|||
start_index: 11, |
|||
end_index: 23, |
|||
base: 2, |
|||
nb_digits: 5, |
|||
expected: vec![vec![0, 1, 0, 1, 1], vec![0, 1, 1], vec![1, 0]], |
|||
}, |
|||
GroupingTestCase { |
|||
start_index: 5677, |
|||
end_index: 8621, |
|||
base: 2, |
|||
nb_digits: 14, |
|||
expected: vec![ |
|||
vec![0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1], |
|||
vec![0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1], |
|||
vec![0, 1, 0, 1, 1, 0, 0, 0, 1, 1], |
|||
vec![0, 1, 0, 1, 1, 0, 0, 1], |
|||
vec![0, 1, 0, 1, 1, 0, 1], |
|||
vec![0, 1, 0, 1, 1, 1], |
|||
vec![0, 1, 1], |
|||
vec![1, 0, 0, 0, 0, 0], |
|||
vec![1, 0, 0, 0, 0, 1, 0], |
|||
vec![1, 0, 0, 0, 0, 1, 1, 0, 0], |
|||
vec![1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0], |
|||
vec![1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0], |
|||
vec![1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0], |
|||
], |
|||
}, |
|||
] |
|||
} |
|||
|
|||
#[test] |
|||
fn decompose_value_test() { |
|||
for test_case in decomposition_test_cases() { |
|||
assert_eq!( |
|||
test_case.decomposed, |
|||
super::decompose_value(test_case.composed, test_case.base, test_case.nb_digits) |
|||
); |
|||
} |
|||
} |
|||
|
|||
#[test] |
|||
fn group_by_ignoring_digits_test() { |
|||
for test_case in grouping_test_cases() { |
|||
assert_eq!( |
|||
test_case.expected, |
|||
super::group_by_ignoring_digits( |
|||
test_case.start_index, |
|||
test_case.end_index, |
|||
test_case.base, |
|||
test_case.nb_digits |
|||
) |
|||
); |
|||
} |
|||
} |
|||
} |
|||
@ -1,12 +0,0 @@ |
|||
mod oracle; |
|||
mod protocol; |
|||
|
|||
pub mod interval; |
|||
|
|||
pub use protocol::{ |
|||
close_transaction, commit_descriptor, compute_adaptor_pk, create_cfd_transactions, |
|||
finalize_spend_transaction, generate_payouts, lock_descriptor, punish_transaction, |
|||
renew_cfd_transactions, spending_tx_sighash, Announcement, Cets, CfdTransactions, PartyParams, |
|||
Payout, PunishParams, TransactionExt, WalletExt, |
|||
}; |
|||
pub use secp256k1_zkp; |
|||
@ -1,40 +0,0 @@ |
|||
pub use secp256k1_zkp::*; |
|||
|
|||
use anyhow::Result; |
|||
use secp256k1_zkp::schnorrsig; |
|||
use std::num::NonZeroU8; |
|||
|
|||
/// Compute an attestation public key for the given oracle public key,
|
|||
/// announcement nonce public key and outcome index.
|
|||
pub fn attestation_pk( |
|||
oracle_pk: &schnorrsig::PublicKey, |
|||
nonce_pk: &schnorrsig::PublicKey, |
|||
index: NonZeroU8, |
|||
) -> Result<secp256k1_zkp::PublicKey> { |
|||
let nonce_pk = schnorr_pubkey_to_pubkey(nonce_pk); |
|||
|
|||
let mut nonce_pk_sum = nonce_pk; |
|||
nonce_pk_sum.mul_assign(SECP256K1, &index_to_bytes(index))?; |
|||
|
|||
let oracle_pk = schnorr_pubkey_to_pubkey(oracle_pk); |
|||
let attestation_pk = oracle_pk.combine(&nonce_pk_sum)?; |
|||
|
|||
Ok(attestation_pk) |
|||
} |
|||
|
|||
fn schnorr_pubkey_to_pubkey(pk: &schnorrsig::PublicKey) -> secp256k1_zkp::PublicKey { |
|||
let mut buf = Vec::<u8>::with_capacity(33); |
|||
|
|||
buf.push(0x02); // append even byte
|
|||
buf.extend(&pk.serialize()); |
|||
|
|||
secp256k1_zkp::PublicKey::from_slice(&buf).expect("valid key") |
|||
} |
|||
|
|||
fn index_to_bytes(index: NonZeroU8) -> [u8; 32] { |
|||
let mut bytes = [0u8; 32]; |
|||
|
|||
bytes[31] = index.get(); |
|||
|
|||
bytes |
|||
} |
|||
@ -1,573 +0,0 @@ |
|||
pub use transaction_ext::TransactionExt; |
|||
pub use transactions::{close_transaction, punish_transaction}; |
|||
|
|||
use crate::protocol::sighash_ext::SigHashExt; |
|||
use crate::protocol::transactions::{ |
|||
lock_transaction, CommitTransaction, ContractExecutionTransaction as ContractExecutionTx, |
|||
RefundTransaction, |
|||
}; |
|||
use crate::{interval, oracle}; |
|||
use anyhow::{bail, Context, Result}; |
|||
use bdk::bitcoin::hashes::hex::ToHex; |
|||
use bdk::bitcoin::util::bip143::SigHashCache; |
|||
use bdk::bitcoin::util::psbt::PartiallySignedTransaction; |
|||
use bdk::bitcoin::{Address, Amount, PublicKey, SigHashType, Transaction, TxOut}; |
|||
use bdk::database::BatchDatabase; |
|||
use bdk::descriptor::Descriptor; |
|||
use bdk::miniscript::descriptor::Wsh; |
|||
use bdk::miniscript::DescriptorTrait; |
|||
use bdk::wallet::AddressIndex; |
|||
use bdk::FeeRate; |
|||
use itertools::Itertools; |
|||
use secp256k1_zkp::{self, schnorrsig, EcdsaAdaptorSignature, SecretKey, Signature, SECP256K1}; |
|||
use std::collections::HashMap; |
|||
use std::hash::Hasher; |
|||
use std::iter::FromIterator; |
|||
use std::num::NonZeroU8; |
|||
use std::ops::RangeInclusive; |
|||
|
|||
mod sighash_ext; |
|||
mod transaction_ext; |
|||
mod transactions; |
|||
mod txin_ext; |
|||
|
|||
/// Static script to be used to create lock tx
|
|||
const DUMMY_2OF2_MULTISIG: &str = |
|||
"0020b5aa99ed7e0fa92483eb045ab8b7a59146d4d9f6653f21ba729b4331895a5b46"; |
|||
|
|||
pub trait WalletExt { |
|||
fn build_party_params(&self, amount: Amount, identity_pk: PublicKey) -> Result<PartyParams>; |
|||
} |
|||
|
|||
impl<B, D> WalletExt for bdk::Wallet<B, D> |
|||
where |
|||
D: BatchDatabase, |
|||
{ |
|||
fn build_party_params(&self, amount: Amount, identity_pk: PublicKey) -> Result<PartyParams> { |
|||
let mut builder = self.build_tx(); |
|||
builder |
|||
.ordering(bdk::wallet::tx_builder::TxOrdering::Bip69Lexicographic) |
|||
.fee_rate(FeeRate::from_sat_per_vb(1.0)) |
|||
.add_recipient( |
|||
DUMMY_2OF2_MULTISIG.parse().expect("Should be valid script"), |
|||
amount.as_sat(), |
|||
); |
|||
let (lock_psbt, _) = builder.finish()?; |
|||
let address = self.get_address(AddressIndex::New)?.address; |
|||
Ok(PartyParams { |
|||
lock_psbt, |
|||
identity_pk, |
|||
lock_amount: amount, |
|||
address, |
|||
}) |
|||
} |
|||
} |
|||
|
|||
/// Build all the transactions and some of the signatures and
|
|||
/// encrypted signatures needed to perform the CFD protocol.
|
|||
///
|
|||
/// # Arguments
|
|||
///
|
|||
/// * `maker` - The initial parameters of the maker.
|
|||
/// * `maker_punish_params` - The punish parameters of the maker.
|
|||
/// * `taker` - The initial parameters of the taker.
|
|||
/// * `taker_punish_params` - The punish parameters of the taker.
|
|||
/// * `oracle_pk` - The public key of the oracle.
|
|||
/// * `cet_timelock` - Relative timelock of the CET transaction with respect to the commit
|
|||
/// transaction.
|
|||
/// * `refund_timelock` - Relative timelock of the refund transaction with respect to the commit
|
|||
/// transaction.
|
|||
/// * `payouts_per_event` - All the possible ways in which the contract can be settled, according to
|
|||
/// the conditions of the bet. The key is the event at which the oracle will attest the price.
|
|||
/// * `identity_sk` - The secret key of the caller, used to sign and encsign different transactions.
|
|||
pub fn create_cfd_transactions( |
|||
(maker, maker_punish_params): (PartyParams, PunishParams), |
|||
(taker, taker_punish_params): (PartyParams, PunishParams), |
|||
oracle_pk: schnorrsig::PublicKey, |
|||
(cet_timelock, refund_timelock): (u32, u32), |
|||
payouts_per_event: HashMap<Announcement, Vec<Payout>>, |
|||
identity_sk: SecretKey, |
|||
) -> Result<CfdTransactions> { |
|||
let lock_tx = lock_transaction( |
|||
maker.lock_psbt.clone(), |
|||
taker.lock_psbt.clone(), |
|||
maker.identity_pk, |
|||
taker.identity_pk, |
|||
maker.lock_amount + taker.lock_amount, |
|||
); |
|||
|
|||
build_cfds( |
|||
lock_tx, |
|||
( |
|||
maker.identity_pk, |
|||
maker.lock_amount, |
|||
maker.address, |
|||
maker_punish_params, |
|||
), |
|||
( |
|||
taker.identity_pk, |
|||
taker.lock_amount, |
|||
taker.address, |
|||
taker_punish_params, |
|||
), |
|||
oracle_pk, |
|||
(cet_timelock, refund_timelock), |
|||
payouts_per_event, |
|||
identity_sk, |
|||
) |
|||
} |
|||
|
|||
pub fn renew_cfd_transactions( |
|||
lock_tx: PartiallySignedTransaction, |
|||
(maker_pk, maker_lock_amount, maker_address, maker_punish_params): ( |
|||
PublicKey, |
|||
Amount, |
|||
Address, |
|||
PunishParams, |
|||
), |
|||
(taker_pk, taker_lock_amount, taker_address, taker_punish_params): ( |
|||
PublicKey, |
|||
Amount, |
|||
Address, |
|||
PunishParams, |
|||
), |
|||
oracle_pk: schnorrsig::PublicKey, |
|||
(cet_timelock, refund_timelock): (u32, u32), |
|||
payouts_per_event: HashMap<Announcement, Vec<Payout>>, |
|||
identity_sk: SecretKey, |
|||
) -> Result<CfdTransactions> { |
|||
build_cfds( |
|||
lock_tx, |
|||
( |
|||
maker_pk, |
|||
maker_lock_amount, |
|||
maker_address, |
|||
maker_punish_params, |
|||
), |
|||
( |
|||
taker_pk, |
|||
taker_lock_amount, |
|||
taker_address, |
|||
taker_punish_params, |
|||
), |
|||
oracle_pk, |
|||
(cet_timelock, refund_timelock), |
|||
payouts_per_event, |
|||
identity_sk, |
|||
) |
|||
} |
|||
|
|||
fn build_cfds( |
|||
lock_tx: PartiallySignedTransaction, |
|||
(maker_pk, maker_lock_amount, maker_address, maker_punish_params): ( |
|||
PublicKey, |
|||
Amount, |
|||
Address, |
|||
PunishParams, |
|||
), |
|||
(taker_pk, taker_lock_amount, taker_address, taker_punish_params): ( |
|||
PublicKey, |
|||
Amount, |
|||
Address, |
|||
PunishParams, |
|||
), |
|||
oracle_pk: schnorrsig::PublicKey, |
|||
(cet_timelock, refund_timelock): (u32, u32), |
|||
payouts_per_event: HashMap<Announcement, Vec<Payout>>, |
|||
identity_sk: SecretKey, |
|||
) -> Result<CfdTransactions> { |
|||
let commit_tx = CommitTransaction::new( |
|||
&lock_tx.global.unsigned_tx, |
|||
( |
|||
maker_pk, |
|||
maker_punish_params.revocation_pk, |
|||
maker_punish_params.publish_pk, |
|||
), |
|||
( |
|||
taker_pk, |
|||
taker_punish_params.revocation_pk, |
|||
taker_punish_params.publish_pk, |
|||
), |
|||
) |
|||
.context("cannot build commit tx")?; |
|||
|
|||
let identity_pk = secp256k1_zkp::PublicKey::from_secret_key(SECP256K1, &identity_sk); |
|||
let commit_encsig = if identity_pk == maker_pk.key { |
|||
commit_tx.encsign(identity_sk, &taker_punish_params.publish_pk) |
|||
} else if identity_pk == taker_pk.key { |
|||
commit_tx.encsign(identity_sk, &maker_punish_params.publish_pk) |
|||
} else { |
|||
bail!("identity sk does not belong to taker or maker") |
|||
}; |
|||
|
|||
let refund = { |
|||
let tx = RefundTransaction::new( |
|||
&commit_tx, |
|||
refund_timelock, |
|||
&maker_address, |
|||
&taker_address, |
|||
maker_lock_amount, |
|||
taker_lock_amount, |
|||
); |
|||
|
|||
let sighash = tx.sighash().to_message(); |
|||
let sig = SECP256K1.sign(&sighash, &identity_sk); |
|||
|
|||
(tx.into_inner(), sig) |
|||
}; |
|||
|
|||
let cets = payouts_per_event |
|||
.into_iter() |
|||
.map(|(event, payouts)| { |
|||
let cets = payouts |
|||
.iter() |
|||
.map(|payout| { |
|||
let cet = ContractExecutionTx::new( |
|||
&commit_tx, |
|||
payout.clone(), |
|||
&maker_address, |
|||
&taker_address, |
|||
event.nonce_pks.as_slice(), |
|||
cet_timelock, |
|||
)?; |
|||
|
|||
let encsig = cet.encsign(identity_sk, &oracle_pk)?; |
|||
|
|||
Ok((cet.into_inner(), encsig, payout.digits.clone())) |
|||
}) |
|||
.collect::<Result<Vec<_>>>() |
|||
.context("cannot build and sign all cets")?; |
|||
|
|||
Ok(Cets { event, cets }) |
|||
}) |
|||
.collect::<Result<_>>()?; |
|||
|
|||
Ok(CfdTransactions { |
|||
lock: lock_tx, |
|||
commit: (commit_tx.into_inner(), commit_encsig), |
|||
cets, |
|||
refund, |
|||
}) |
|||
} |
|||
|
|||
pub fn lock_descriptor(maker_pk: PublicKey, taker_pk: PublicKey) -> Descriptor<PublicKey> { |
|||
const MINISCRIPT_TEMPLATE: &str = "c:and_v(v:pk(A),pk_k(B))"; |
|||
|
|||
let maker_pk = ToHex::to_hex(&maker_pk.key); |
|||
let taker_pk = ToHex::to_hex(&taker_pk.key); |
|||
|
|||
let miniscript = MINISCRIPT_TEMPLATE |
|||
.replace("A", &maker_pk) |
|||
.replace("B", &taker_pk); |
|||
|
|||
let miniscript = miniscript.parse().expect("a valid miniscript"); |
|||
|
|||
Descriptor::Wsh(Wsh::new(miniscript).expect("a valid descriptor")) |
|||
} |
|||
|
|||
pub fn commit_descriptor( |
|||
(maker_own_pk, maker_rev_pk, maker_publish_pk): (PublicKey, PublicKey, PublicKey), |
|||
(taker_own_pk, taker_rev_pk, taker_publish_pk): (PublicKey, PublicKey, PublicKey), |
|||
) -> Descriptor<PublicKey> { |
|||
let maker_own_pk_hash = maker_own_pk.pubkey_hash().as_hash(); |
|||
let maker_own_pk = (&maker_own_pk.key.serialize().to_vec()).to_hex(); |
|||
let maker_publish_pk_hash = maker_publish_pk.pubkey_hash().as_hash(); |
|||
let maker_rev_pk_hash = maker_rev_pk.pubkey_hash().as_hash(); |
|||
|
|||
let taker_own_pk_hash = taker_own_pk.pubkey_hash().as_hash(); |
|||
let taker_own_pk = (&taker_own_pk.key.serialize().to_vec()).to_hex(); |
|||
let taker_publish_pk_hash = taker_publish_pk.pubkey_hash().as_hash(); |
|||
let taker_rev_pk_hash = taker_rev_pk.pubkey_hash().as_hash(); |
|||
|
|||
// raw script:
|
|||
// or(and(pk(maker_own_pk),pk(taker_own_pk)),or(and(pk(maker_own_pk),and(pk(taker_publish_pk),
|
|||
// pk(taker_rev_pk))),and(pk(taker_own_pk),and(pk(maker_publish_pk),pk(maker_rev_pk)))))
|
|||
let full_script = format!("wsh(c:andor(pk({maker_own_pk}),pk_k({taker_own_pk}),or_i(and_v(v:pkh({maker_own_pk_hash}),and_v(v:pkh({taker_publish_pk_hash}),pk_h({taker_rev_pk_hash}))),and_v(v:pkh({taker_own_pk_hash}),and_v(v:pkh({maker_publish_pk_hash}),pk_h({maker_rev_pk_hash}))))))", |
|||
maker_own_pk = maker_own_pk, |
|||
taker_own_pk = taker_own_pk, |
|||
maker_own_pk_hash = maker_own_pk_hash, |
|||
taker_own_pk_hash = taker_own_pk_hash, |
|||
taker_publish_pk_hash = taker_publish_pk_hash, |
|||
taker_rev_pk_hash = taker_rev_pk_hash, |
|||
maker_publish_pk_hash = maker_publish_pk_hash, |
|||
maker_rev_pk_hash = maker_rev_pk_hash |
|||
); |
|||
|
|||
full_script.parse().expect("a valid miniscript") |
|||
} |
|||
|
|||
pub fn spending_tx_sighash( |
|||
spending_tx: &Transaction, |
|||
spent_descriptor: &Descriptor<PublicKey>, |
|||
spent_amount: Amount, |
|||
) -> secp256k1_zkp::Message { |
|||
let sighash = SigHashCache::new(spending_tx).signature_hash( |
|||
0, |
|||
&spent_descriptor.script_code(), |
|||
spent_amount.as_sat(), |
|||
SigHashType::All, |
|||
); |
|||
sighash.to_message() |
|||
} |
|||
|
|||
pub fn finalize_spend_transaction( |
|||
mut tx: Transaction, |
|||
spent_descriptor: &Descriptor<PublicKey>, |
|||
(pk_0, sig_0): (PublicKey, Signature), |
|||
(pk_1, sig_1): (PublicKey, Signature), |
|||
) -> Result<Transaction> { |
|||
let satisfier = HashMap::from_iter(vec![ |
|||
(pk_0, (sig_0, SigHashType::All)), |
|||
(pk_1, (sig_1, SigHashType::All)), |
|||
]); |
|||
|
|||
let input = tx |
|||
.input |
|||
.iter_mut() |
|||
.exactly_one() |
|||
.expect("all spend transactions to have one input"); |
|||
spent_descriptor.satisfy(input, satisfier)?; |
|||
|
|||
Ok(tx) |
|||
} |
|||
|
|||
#[derive(Clone)] |
|||
pub struct PartyParams { |
|||
pub lock_psbt: PartiallySignedTransaction, |
|||
pub identity_pk: PublicKey, |
|||
pub lock_amount: Amount, |
|||
pub address: Address, |
|||
} |
|||
|
|||
#[derive(Debug, Copy, Clone)] |
|||
pub struct PunishParams { |
|||
pub revocation_pk: PublicKey, |
|||
pub publish_pk: PublicKey, |
|||
} |
|||
|
|||
#[derive(Debug, Clone)] |
|||
pub struct CfdTransactions { |
|||
pub lock: PartiallySignedTransaction, |
|||
pub commit: (Transaction, EcdsaAdaptorSignature), |
|||
pub cets: Vec<Cets>, |
|||
pub refund: (Transaction, Signature), |
|||
} |
|||
|
|||
/// Group of CETs associated with a particular oracle announcement.
|
|||
///
|
|||
/// All of the adaptor signatures included will be _possibly_ unlocked
|
|||
/// by the attestation corresponding to the announcement. In practice,
|
|||
/// only one of the adaptor signatures should be unlocked if the
|
|||
/// payout intervals are constructed correctly. To check if an adaptor
|
|||
/// signature can be unlocked by a price attestation, verify whether
|
|||
/// the price attested to lies within its interval.
|
|||
#[derive(Debug, Clone)] |
|||
pub struct Cets { |
|||
pub event: Announcement, |
|||
pub cets: Vec<(Transaction, EcdsaAdaptorSignature, interval::Digits)>, |
|||
} |
|||
|
|||
#[derive(Debug, Clone, Eq)] |
|||
pub struct Announcement { |
|||
pub id: String, |
|||
pub nonce_pks: Vec<schnorrsig::PublicKey>, |
|||
} |
|||
|
|||
impl std::hash::Hash for Announcement { |
|||
fn hash<H: Hasher>(&self, state: &mut H) { |
|||
self.id.hash(state) |
|||
} |
|||
} |
|||
|
|||
impl PartialEq for Announcement { |
|||
fn eq(&self, other: &Self) -> bool { |
|||
self.id.eq(&other.id) |
|||
} |
|||
} |
|||
|
|||
#[derive(Debug, Clone, PartialEq)] |
|||
pub struct Payout { |
|||
digits: interval::Digits, |
|||
maker_amount: Amount, |
|||
taker_amount: Amount, |
|||
} |
|||
|
|||
pub fn generate_payouts( |
|||
range: RangeInclusive<u64>, |
|||
maker_amount: Amount, |
|||
taker_amount: Amount, |
|||
) -> Result<Vec<Payout>> { |
|||
let digits = interval::Digits::new(range).context("invalid interval")?; |
|||
Ok(digits |
|||
.into_iter() |
|||
.map(|digits| Payout { |
|||
digits, |
|||
maker_amount, |
|||
taker_amount, |
|||
}) |
|||
.collect()) |
|||
} |
|||
|
|||
impl Payout { |
|||
pub fn digits(&self) -> &interval::Digits { |
|||
&self.digits |
|||
} |
|||
|
|||
pub fn maker_amount(&self) -> &Amount { |
|||
&self.maker_amount |
|||
} |
|||
|
|||
pub fn taker_amount(&self) -> &Amount { |
|||
&self.taker_amount |
|||
} |
|||
|
|||
fn into_txouts(self, maker_address: &Address, taker_address: &Address) -> Vec<TxOut> { |
|||
let txouts = [ |
|||
(self.maker_amount, maker_address), |
|||
(self.taker_amount, taker_address), |
|||
] |
|||
.iter() |
|||
.filter_map(|(amount, address)| { |
|||
let script_pubkey = address.script_pubkey(); |
|||
let dust_limit = script_pubkey.dust_value(); |
|||
(amount >= &dust_limit).then(|| TxOut { |
|||
value: amount.as_sat(), |
|||
script_pubkey, |
|||
}) |
|||
}) |
|||
.collect::<Vec<_>>(); |
|||
|
|||
txouts |
|||
} |
|||
|
|||
/// Subtracts fee fairly from both outputs
|
|||
///
|
|||
/// We need to consider a few cases:
|
|||
/// - If both amounts are >= DUST, they share the fee equally
|
|||
/// - If one amount is < DUST, it set to 0 and the other output needs to cover for the fee.
|
|||
fn with_updated_fee( |
|||
self, |
|||
fee: Amount, |
|||
dust_limit_maker: Amount, |
|||
dust_limit_taker: Amount, |
|||
) -> Result<Self> { |
|||
let maker_amount = self.maker_amount; |
|||
let taker_amount = self.taker_amount; |
|||
|
|||
let mut updated = self; |
|||
match ( |
|||
maker_amount |
|||
.checked_sub(fee / 2) |
|||
.map(|a| a > dust_limit_maker) |
|||
.unwrap_or(false), |
|||
taker_amount |
|||
.checked_sub(fee / 2) |
|||
.map(|a| a > dust_limit_taker) |
|||
.unwrap_or(false), |
|||
) { |
|||
(true, true) => { |
|||
updated.maker_amount -= fee / 2; |
|||
updated.taker_amount -= fee / 2; |
|||
} |
|||
(false, true) => { |
|||
updated.maker_amount = Amount::ZERO; |
|||
updated.taker_amount = taker_amount - (fee + maker_amount); |
|||
} |
|||
(true, false) => { |
|||
updated.maker_amount = maker_amount - (fee + taker_amount); |
|||
updated.taker_amount = Amount::ZERO; |
|||
} |
|||
(false, false) => bail!("Amounts are too small, could not subtract fee."), |
|||
} |
|||
Ok(updated) |
|||
} |
|||
} |
|||
|
|||
pub fn compute_adaptor_pk( |
|||
oracle_pk: &schnorrsig::PublicKey, |
|||
index_nonce_pairs: &[(NonZeroU8, schnorrsig::PublicKey)], |
|||
) -> Result<secp256k1_zkp::PublicKey> { |
|||
let attestation_pks = index_nonce_pairs |
|||
.iter() |
|||
.map(|(index, nonce_pk)| oracle::attestation_pk(oracle_pk, nonce_pk, *index)) |
|||
.collect::<Result<Vec<_>>>()?; |
|||
let adaptor_pk = secp256k1_zkp::PublicKey::combine_keys( |
|||
attestation_pks.iter().collect::<Vec<_>>().as_slice(), |
|||
)?; |
|||
|
|||
Ok(adaptor_pk) |
|||
} |
|||
|
|||
#[cfg(test)] |
|||
mod tests { |
|||
use super::*; |
|||
|
|||
use bdk::bitcoin::Network; |
|||
|
|||
// TODO add proptest for this
|
|||
|
|||
#[test] |
|||
fn test_fee_subtraction_bigger_than_dust() { |
|||
let key = "032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af" |
|||
.parse() |
|||
.unwrap(); |
|||
let dummy_address = Address::p2wpkh(&key, Network::Regtest).unwrap(); |
|||
let dummy_dust_limit = dummy_address.script_pubkey().dust_value(); |
|||
|
|||
let orig_maker_amount = 1000; |
|||
let orig_taker_amount = 1000; |
|||
let payouts = generate_payouts( |
|||
0..=10_000, |
|||
Amount::from_sat(orig_maker_amount), |
|||
Amount::from_sat(orig_taker_amount), |
|||
) |
|||
.unwrap(); |
|||
let fee = 100; |
|||
|
|||
for payout in payouts { |
|||
let updated_payout = payout |
|||
.with_updated_fee(Amount::from_sat(fee), dummy_dust_limit, dummy_dust_limit) |
|||
.unwrap(); |
|||
|
|||
assert_eq!( |
|||
updated_payout.maker_amount, |
|||
Amount::from_sat(orig_maker_amount - fee / 2) |
|||
); |
|||
assert_eq!( |
|||
updated_payout.taker_amount, |
|||
Amount::from_sat(orig_taker_amount - fee / 2) |
|||
); |
|||
} |
|||
} |
|||
|
|||
#[test] |
|||
fn test_fee_subtraction_smaller_than_dust() { |
|||
let key = "032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af" |
|||
.parse() |
|||
.unwrap(); |
|||
let dummy_address = Address::p2wpkh(&key, Network::Regtest).unwrap(); |
|||
let dummy_dust_limit = dummy_address.script_pubkey().dust_value(); |
|||
|
|||
let orig_maker_amount = dummy_dust_limit.as_sat() - 1; |
|||
let orig_taker_amount = 1000; |
|||
let payouts = generate_payouts( |
|||
0..=10_000, |
|||
Amount::from_sat(orig_maker_amount), |
|||
Amount::from_sat(orig_taker_amount), |
|||
) |
|||
.unwrap(); |
|||
let fee = 100; |
|||
|
|||
for payout in payouts { |
|||
let updated_payout = payout |
|||
.with_updated_fee(Amount::from_sat(fee), dummy_dust_limit, dummy_dust_limit) |
|||
.unwrap(); |
|||
|
|||
assert_eq!(updated_payout.maker_amount, Amount::from_sat(0)); |
|||
assert_eq!( |
|||
updated_payout.taker_amount, |
|||
Amount::from_sat(orig_taker_amount - (fee + orig_maker_amount)) |
|||
); |
|||
} |
|||
} |
|||
} |
|||
@ -1,15 +0,0 @@ |
|||
use bdk::bitcoin::hashes::Hash; |
|||
use bdk::bitcoin::SigHash; |
|||
|
|||
pub(crate) 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() |
|||
} |
|||
} |
|||
@ -1,26 +0,0 @@ |
|||
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, |
|||
}) |
|||
} |
|||
} |
|||
@ -1,596 +0,0 @@ |
|||
use crate::protocol::sighash_ext::SigHashExt; |
|||
use crate::protocol::transaction_ext::TransactionExt; |
|||
use crate::protocol::txin_ext::TxInExt; |
|||
use crate::protocol::{ |
|||
commit_descriptor, compute_adaptor_pk, 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, SECP256K1}; |
|||
use std::collections::HashMap; |
|||
use std::iter::FromIterator; |
|||
use std::num::NonZeroU8; |
|||
|
|||
/// In satoshi per vbyte.
|
|||
const SATS_PER_VBYTE: f64 = 1.0; |
|||
|
|||
pub(crate) 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(crate) struct CommitTransaction { |
|||
inner: Transaction, |
|||
descriptor: Descriptor<PublicKey>, |
|||
amount: Amount, |
|||
sighash: SigHash, |
|||
lock_descriptor: Descriptor<PublicKey>, |
|||
fee: Fee, |
|||
} |
|||
|
|||
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(crate) 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 = Fee::new(Self::SIGNED_VBYTES); |
|||
|
|||
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(crate) fn encsign( |
|||
&self, |
|||
sk: SecretKey, |
|||
publish_them_pk: &PublicKey, |
|||
) -> EcdsaAdaptorSignature { |
|||
EcdsaAdaptorSignature::encrypt( |
|||
SECP256K1, |
|||
&self.sighash.to_message(), |
|||
&sk, |
|||
&publish_them_pk.key, |
|||
) |
|||
} |
|||
|
|||
pub(crate) 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.as_u64() |
|||
} |
|||
} |
|||
|
|||
#[derive(Debug, Clone)] |
|||
pub(crate) struct ContractExecutionTransaction { |
|||
inner: Transaction, |
|||
index_nonce_pairs: Vec<(NonZeroU8, 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(crate) fn new( |
|||
commit_tx: &CommitTransaction, |
|||
payout: Payout, |
|||
maker_address: &Address, |
|||
taker_address: &Address, |
|||
nonce_pks: &[schnorrsig::PublicKey], |
|||
relative_timelock_in_blocks: u32, |
|||
) -> Result<Self> { |
|||
let index_nonce_pairs: Vec<_> = payout |
|||
.digits |
|||
.to_indices() |
|||
.into_iter() |
|||
.zip(nonce_pks.iter().cloned()) |
|||
.collect(); |
|||
|
|||
let commit_input = TxIn { |
|||
previous_output: commit_tx.outpoint(), |
|||
sequence: relative_timelock_in_blocks, |
|||
..Default::default() |
|||
}; |
|||
|
|||
let fee = Fee::new(Self::SIGNED_VBYTES).add(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, |
|||
index_nonce_pairs, |
|||
sighash, |
|||
commit_descriptor: commit_tx.descriptor(), |
|||
}) |
|||
} |
|||
|
|||
pub(crate) fn encsign( |
|||
&self, |
|||
sk: SecretKey, |
|||
oracle_pk: &schnorrsig::PublicKey, |
|||
) -> Result<EcdsaAdaptorSignature> { |
|||
let adaptor_point = compute_adaptor_pk(oracle_pk, &self.index_nonce_pairs)?; |
|||
|
|||
Ok(EcdsaAdaptorSignature::encrypt( |
|||
SECP256K1, |
|||
&self.sighash.to_message(), |
|||
&sk, |
|||
&adaptor_point, |
|||
)) |
|||
} |
|||
|
|||
pub(crate) fn into_inner(self) -> Transaction { |
|||
self.inner |
|||
} |
|||
} |
|||
|
|||
#[derive(Debug, Clone)] |
|||
pub(crate) 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(crate) 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(crate) fn sighash(&self) -> SigHash { |
|||
self.sighash |
|||
} |
|||
|
|||
pub(crate) fn into_inner(self) -> Transaction { |
|||
self.inner |
|||
} |
|||
} |
|||
|
|||
/// Build a transaction which closes the CFD contract.
|
|||
///
|
|||
/// This transaction spends directly from the lock transaction. Both
|
|||
/// parties must agree on the split of coins between `maker_amount`
|
|||
/// and `taker_amount`.
|
|||
pub fn close_transaction( |
|||
lock_descriptor: &Descriptor<PublicKey>, |
|||
lock_outpoint: OutPoint, |
|||
lock_amount: Amount, |
|||
(maker_address, maker_amount): (&Address, Amount), |
|||
(taker_address, taker_amount): (&Address, Amount), |
|||
) -> Result<(Transaction, secp256k1_zkp::Message)> { |
|||
/// Expected size of signed transaction in virtual bytes, plus a
|
|||
/// buffer to account for different signature lengths.
|
|||
const SIGNED_VBYTES: f64 = 167.5 + (3.0 * 2.0) / 4.0; |
|||
|
|||
let lock_input = TxIn { |
|||
previous_output: lock_outpoint, |
|||
..Default::default() |
|||
}; |
|||
|
|||
// TODO: The fee could take into account the network state in this
|
|||
// case, since this transaction is to be broadcast immediately
|
|||
// after building and signing it
|
|||
let (maker_fee, taker_fee) = Fee::new(SIGNED_VBYTES).split(); |
|||
|
|||
let maker_output = TxOut { |
|||
value: maker_amount.as_sat() - maker_fee, |
|||
script_pubkey: maker_address.script_pubkey(), |
|||
}; |
|||
let taker_output = TxOut { |
|||
value: taker_amount.as_sat() - taker_fee, |
|||
script_pubkey: taker_address.script_pubkey(), |
|||
}; |
|||
|
|||
let tx = Transaction { |
|||
version: 2, |
|||
lock_time: 0, |
|||
input: vec![lock_input], |
|||
output: vec![maker_output, taker_output], |
|||
}; |
|||
|
|||
let sighash = SigHashCache::new(&tx) |
|||
.signature_hash( |
|||
0, |
|||
&lock_descriptor.script_code(), |
|||
lock_amount.as_sat(), |
|||
SigHashType::All, |
|||
) |
|||
.to_message(); |
|||
|
|||
Ok((tx, sighash)) |
|||
} |
|||
|
|||
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 |
|||
.find_map_signature(|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) |
|||
} |
|||
|
|||
#[derive(Clone, Debug)] |
|||
struct Fee { |
|||
fee: f64, |
|||
} |
|||
|
|||
impl Fee { |
|||
fn new(signed_vbytes: f64) -> Self { |
|||
let fee = signed_vbytes * SATS_PER_VBYTE; |
|||
Self { fee } |
|||
} |
|||
|
|||
#[must_use] |
|||
fn add(self, number: f64) -> Fee { |
|||
Fee { |
|||
fee: self.fee + number, |
|||
} |
|||
} |
|||
|
|||
fn as_u64(&self) -> u64 { |
|||
// Ceil to prevent going lower than the min relay fee
|
|||
self.fee.ceil() as u64 |
|||
} |
|||
|
|||
fn split(&self) -> (u64, u64) { |
|||
let half = self.as_u64() / 2; |
|||
(half as u64, self.as_u64() - half) |
|||
} |
|||
} |
|||
|
|||
#[cfg(test)] |
|||
mod tests { |
|||
use super::*; |
|||
use proptest::prelude::*; |
|||
|
|||
proptest! { |
|||
#[test] |
|||
fn test_fee_always_above_min_relay_fee(signed_vbytes in 1.0f64..100_000_000.0f64) { |
|||
let fee = Fee::new(signed_vbytes); |
|||
let (maker_fee, taker_fee) = fee.split(); |
|||
|
|||
prop_assert!(signed_vbytes <= fee.as_u64() as f64); |
|||
prop_assert!(signed_vbytes <= (maker_fee + taker_fee) as f64); |
|||
} |
|||
} |
|||
|
|||
// A bunch of tests illustrating how fees are split
|
|||
|
|||
#[test] |
|||
fn test_splitting_fee_1_0() { |
|||
const SIGNED_VBYTES_TEST: f64 = 1.0; |
|||
|
|||
let fee = Fee::new(SIGNED_VBYTES_TEST); |
|||
let (maker_fee, taker_fee) = fee.split(); |
|||
|
|||
assert_eq!(fee.as_u64(), 1); |
|||
assert_eq!(maker_fee, 0); |
|||
assert_eq!(taker_fee, 1); |
|||
assert!((maker_fee + taker_fee) as f64 >= SIGNED_VBYTES_TEST); |
|||
} |
|||
|
|||
#[test] |
|||
fn test_splitting_fee_2_0() { |
|||
const SIGNED_VBYTES_TEST: f64 = 2.0; |
|||
|
|||
let fee = Fee::new(SIGNED_VBYTES_TEST); |
|||
let (maker_fee, taker_fee) = fee.split(); |
|||
|
|||
assert_eq!(fee.as_u64(), 2); |
|||
assert_eq!(maker_fee, 1); |
|||
assert_eq!(taker_fee, 1); |
|||
assert!((maker_fee + taker_fee) as f64 >= SIGNED_VBYTES_TEST); |
|||
} |
|||
|
|||
#[test] |
|||
fn test_splitting_fee_2_1() { |
|||
const SIGNED_VBYTES_TEST: f64 = 2.1; |
|||
|
|||
let fee = Fee::new(SIGNED_VBYTES_TEST); |
|||
let (maker_fee, taker_fee) = fee.split(); |
|||
|
|||
assert_eq!(fee.as_u64(), 3); |
|||
assert_eq!(maker_fee, 1); |
|||
assert_eq!(taker_fee, 2); |
|||
assert!((maker_fee + taker_fee) as f64 >= SIGNED_VBYTES_TEST); |
|||
} |
|||
|
|||
#[test] |
|||
fn test_splitting_fee_2_6() { |
|||
const SIGNED_VBYTES_TEST: f64 = 2.6; |
|||
|
|||
let fee = Fee::new(SIGNED_VBYTES_TEST); |
|||
let (maker_fee, taker_fee) = fee.split(); |
|||
|
|||
assert_eq!(fee.as_u64(), 3); |
|||
assert_eq!(maker_fee, 1); |
|||
assert_eq!(taker_fee, 2); |
|||
assert!((maker_fee + taker_fee) as f64 >= SIGNED_VBYTES_TEST); |
|||
} |
|||
} |
|||
@ -1,23 +0,0 @@ |
|||
use bdk::bitcoin::secp256k1::Signature; |
|||
use bdk::bitcoin::TxIn; |
|||
|
|||
pub(crate) trait TxInExt { |
|||
fn find_map_signature<F, R>(&self, f: F) -> Option<R> |
|||
where |
|||
F: Fn(Signature) -> Option<R>; |
|||
} |
|||
|
|||
impl TxInExt for TxIn { |
|||
fn find_map_signature<F, R>(&self, f: F) -> Option<R> |
|||
where |
|||
F: Fn(Signature) -> Option<R>, |
|||
{ |
|||
self.witness |
|||
.iter() |
|||
.filter_map(|elem| { |
|||
let elem = elem.as_slice(); |
|||
Signature::from_der(&elem[..elem.len() - 1]).ok() |
|||
}) |
|||
.find_map(f) |
|||
} |
|||
} |
|||
File diff suppressed because it is too large
Loading…
Reference in new issue