milksad
/
rust-bitcoin-unsafe-fast
14
0
Fork 0
Code Issues Pull Requests Activity

Merge rust-bitcoin/rust-bitcoin#2263: `TaprootMerkleBranch` improvements 

e1cc98986c Put `#[inline]` on trivial functions (Martin Habovstiak)
e531fa612b Move `TaprootMerkleBranch` and impl `IntoIterator` (Martin Habovstiak)
9d23c1d0a8 Implement std traits for `TaprootMerkleBranch` (Martin Habovstiak)
93b415589d Rename `inner` to `slice`/`vec` (Martin Habovstiak)
bb0f839c2f Lint with nightly (Martin Habovstiak)

Pull request description:

  This contains several improvements to `TaprootMerkleBranch` that make the API more idiomatic.

ACKs for top commit:
  tcharding:
    ACK e1cc98986c
  apoelstra:
    ACK e1cc98986c

Tree-SHA512: b2bf52b027e7c1f8588c54e8b8d7a5fa54011dc521bd917995011d5fcc16c50a486eb89c0cdae2557a58adbe7708a4f2bc8f4c492e3d88c679f2abf85b1e7c83
This commit is contained in:
Andrew Poelstra 2023-12-11 13:58:06 +00:00
parent c53402790e e1cc98986c
commit e0886e6a5f
No known key found for this signature in database
GPG Key ID: C588D63CE41B97C1
4 changed files with 318 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.github/workflows/rust.yml vendored
View File

@ -22,7 +22,6 @@ jobs:
- name: Running test script
env:
DO_COV: true
DO_LINT: true
AS_DEPENDENCY: false
DO_DOCS: true
DO_FEATURE_MATRIX: true
@ -54,8 +53,11 @@ jobs:
uses: actions/checkout@v4
- name: Checkout Toolchain
uses: dtolnay/rust-toolchain@nightly
- name: Install clippy
run: rustup component add clippy
- name: Running test script
env:
DO_LINT: true
DO_FMT: false
DO_BENCH: true
AS_DEPENDENCY: false

2
bitcoin/src/lib.rs
View File

@ -171,7 +171,7 @@ mod prelude {
pub use alloc::sync;
#[cfg(any(feature = "std", test))]
pub use std::{string::{String, ToString}, vec::Vec, boxed::Box, borrow::{Borrow, BorrowMut, Cow, ToOwned}, slice, rc, sync};
pub use std::{string::{String, ToString}, vec::Vec, boxed::Box, borrow::{Borrow, BorrowMut, Cow, ToOwned}, rc, sync};
#[cfg(all(not(feature = "std"), not(test)))]
pub use alloc::collections::{BTreeMap, BTreeSet, btree_map, BinaryHeap};

304
bitcoin/src/taproot/merkle_branch.rs Normal file
View File

@ -0,0 +1,304 @@
// SPDX-License-Identifier: CC0-1.0
//! Contains `TaprootMerkleBranch` and its associated types.
use alloc::boxed::Box;
use alloc::vec::Vec;
use core::borrow::{Borrow, BorrowMut};
use super::{TapNodeHash, TaprootError, TaprootBuilderError, TAPROOT_CONTROL_NODE_SIZE, TAPROOT_CONTROL_MAX_NODE_COUNT};
use hashes::Hash;
/// The merkle proof for inclusion of a tree in a taptree hash.
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
#[cfg_attr(feature = "serde", serde(into = "Vec<TapNodeHash>"))]
#[cfg_attr(feature = "serde", serde(try_from = "Vec<TapNodeHash>"))]
pub struct TaprootMerkleBranch(Vec<TapNodeHash>);
impl TaprootMerkleBranch {
/// Returns a reference to the slice of hashes.
#[deprecated(since = "TBD", note = "Use `as_slice` instead")]
#[inline]
pub fn as_inner(&self) -> &[TapNodeHash] { &self.0 }
/// Returns a reference to the slice of hashes.
#[inline]
pub fn as_slice(&self) -> &[TapNodeHash] { &self.0 }
/// Returns the number of nodes in this merkle proof.
#[inline]
pub fn len(&self) -> usize { self.0.len() }
/// Checks if this merkle proof is empty.
#[inline]
pub fn is_empty(&self) -> bool { self.0.is_empty() }
/// Decodes bytes from control block.
///
/// This reads the branch as encoded in the control block: the concatenated 32B byte chunks -
/// one for each hash.
///
/// # Errors
///
/// The function returns an error if the the number of bytes is not an integer multiple of 32 or
/// if the number of hashes exceeds 128.
pub fn decode(sl: &[u8]) -> Result<Self, TaprootError> {
if sl.len() % TAPROOT_CONTROL_NODE_SIZE != 0 {
Err(TaprootError::InvalidMerkleBranchSize(sl.len()))
} else if sl.len() > TAPROOT_CONTROL_NODE_SIZE * TAPROOT_CONTROL_MAX_NODE_COUNT {
Err(TaprootError::InvalidMerkleTreeDepth(sl.len() / TAPROOT_CONTROL_NODE_SIZE))
} else {
let inner = sl
.chunks_exact(TAPROOT_CONTROL_NODE_SIZE)
.map(|chunk| {
TapNodeHash::from_slice(chunk)
.expect("chunks_exact always returns the correct size")
})
.collect();
Ok(TaprootMerkleBranch(inner))
}
}
/// Creates a merkle proof from list of hashes.
///
/// # Errors
/// If inner proof length is more than [`TAPROOT_CONTROL_MAX_NODE_COUNT`] (128).
#[inline]
fn from_collection<T: AsRef<[TapNodeHash]> + Into<Vec<TapNodeHash>>>(
collection: T,
) -> Result<Self, TaprootError> {
if collection.as_ref().len() > TAPROOT_CONTROL_MAX_NODE_COUNT {
Err(TaprootError::InvalidMerkleTreeDepth(collection.as_ref().len()))
} else {
Ok(TaprootMerkleBranch(collection.into()))
}
}
/// Serializes to a writer.
///
/// # Returns
///
/// The number of bytes written to the writer.
pub fn encode<Write: io::Write + ?Sized>(&self, writer: &mut Write) -> io::Result<usize> {
for hash in self {
writer.write_all(hash.as_ref())?;
}
Ok(self.len() * TapNodeHash::LEN)
}
/// Serializes `self` as bytes.
pub fn serialize(&self) -> Vec<u8> {
self.iter().flat_map(|e| e.as_byte_array()).copied().collect::<Vec<u8>>()
}
/// Appends elements to proof.
pub(super) fn push(&mut self, h: TapNodeHash) -> Result<(), TaprootBuilderError> {
if self.len() >= TAPROOT_CONTROL_MAX_NODE_COUNT {
Err(TaprootBuilderError::InvalidMerkleTreeDepth(self.0.len()))
} else {
self.0.push(h);
Ok(())
}
}
/// Returns the inner list of hashes.
#[deprecated(since = "TBD", note = "Use `into_vec` instead")]
#[inline]
pub fn into_inner(self) -> Vec<TapNodeHash> { self.0 }
/// Returns the list of hashes stored in a `Vec`.
#[inline]
pub fn into_vec(self) -> Vec<TapNodeHash> { self.0 }
}
macro_rules! impl_try_from {
($from:ty) => {
impl TryFrom<$from> for TaprootMerkleBranch {
type Error = TaprootError;
/// Creates a merkle proof from list of hashes.
///
/// # Errors
/// If inner proof length is more than [`TAPROOT_CONTROL_MAX_NODE_COUNT`] (128).
#[inline]
fn try_from(v: $from) -> Result<Self, Self::Error> {
TaprootMerkleBranch::from_collection(v)
}
}
};
}
impl_try_from!(&[TapNodeHash]);
impl_try_from!(Vec<TapNodeHash>);
impl_try_from!(Box<[TapNodeHash]>);
macro_rules! impl_try_from_array {
($($len:expr),* $(,)?) => {
$(
impl From<[TapNodeHash; $len]> for TaprootMerkleBranch {
#[inline]
fn from(a: [TapNodeHash; $len]) -> Self {
Self(a.to_vec())
}
}
)*
}
}
// Implement for all values [0, 128] inclusive.
//
// The reason zero is included is that `TaprootMerkleBranch` doesn't contain the hash of the node
// that's being proven - it's not needed because the script is already right before control block.
impl_try_from_array!(
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128
);
impl From<TaprootMerkleBranch> for Vec<TapNodeHash> {
#[inline]
fn from(branch: TaprootMerkleBranch) -> Self { branch.0 }
}
impl IntoIterator for TaprootMerkleBranch {
type IntoIter = IntoIter;
type Item = TapNodeHash;
#[inline]
fn into_iter(self) -> Self::IntoIter {
IntoIter(self.0.into_iter())
}
}
impl<'a> IntoIterator for &'a TaprootMerkleBranch {
type IntoIter = core::slice::Iter<'a, TapNodeHash>;
type Item = &'a TapNodeHash;
#[inline]
fn into_iter(self) -> Self::IntoIter {
self.0.iter()
}
}
impl<'a> IntoIterator for &'a mut TaprootMerkleBranch {
type IntoIter = core::slice::IterMut<'a, TapNodeHash>;
type Item = &'a mut TapNodeHash;
#[inline]
fn into_iter(self) -> Self::IntoIter {
self.0.iter_mut()
}
}
impl core::ops::Deref for TaprootMerkleBranch {
type Target = [TapNodeHash];
#[inline]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for TaprootMerkleBranch {
#[inline]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl AsRef<[TapNodeHash]> for TaprootMerkleBranch {
#[inline]
fn as_ref(&self) -> &[TapNodeHash] {
&self.0
}
}
impl AsMut<[TapNodeHash]> for TaprootMerkleBranch {
#[inline]
fn as_mut(&mut self) -> &mut [TapNodeHash] {
&mut self.0
}
}
impl Borrow<[TapNodeHash]> for TaprootMerkleBranch {
#[inline]
fn borrow(&self) -> &[TapNodeHash] {
&self.0
}
}
impl BorrowMut<[TapNodeHash]> for TaprootMerkleBranch {
#[inline]
fn borrow_mut(&mut self) -> &mut [TapNodeHash] {
&mut self.0
}
}
/// Iterator over node hashes within Taproot merkle branch.
///
/// This is created by `into_iter` method on `TaprootMerkleBranch` (via `IntoIterator` trait).
#[derive(Clone, Debug)]
pub struct IntoIter(alloc::vec::IntoIter<TapNodeHash>);
impl IntoIter {
/// Returns the remaining items of this iterator as a slice.
#[inline]
pub fn as_slice(&self) -> &[TapNodeHash] {
self.0.as_slice()
}
/// Returns the remaining items of this iterator as a mutable slice.
#[inline]
pub fn as_mut_slice(&mut self) -> &mut [TapNodeHash] {
self.0.as_mut_slice()
}
}
impl Iterator for IntoIter {
type Item = TapNodeHash;
#[inline]
fn next(&mut self) -> Option<Self::Item> {
self.0.next()
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
self.0.size_hint()
}
#[inline]
fn nth(&mut self, n: usize) -> Option<Self::Item> {
self.0.nth(n)
}
#[inline]
fn last(self) -> Option<Self::Item> {
self.0.last()
}
#[inline]
fn count(self) -> usize {
self.0.count()
}
}
impl DoubleEndedIterator for IntoIter {
#[inline]
fn next_back(&mut self) -> Option<Self::Item> {
self.0.next_back()
}
#[inline]
fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
self.0.nth_back(n)
}
}
impl ExactSizeIterator for IntoIter {}
impl core::iter::FusedIterator for IntoIter {}

155
bitcoin/src/taproot/mod.rs
View File

@ -6,6 +6,7 @@
//!
pub mod serialized_signature;
pub mod merkle_branch;
use core::cmp::Reverse;
use core::fmt;
@ -24,6 +25,8 @@ use crate::{io, Script, ScriptBuf};
#[rustfmt::skip]
#[doc(inline)]
pub use crate::crypto::taproot::{SigFromSliceError, Signature};
#[doc(inline)]
pub use merkle_branch::TaprootMerkleBranch;
// Taproot test vectors from BIP-341 state the hashes without any reversing
sha256t_hash_newtype! {
@ -306,7 +309,7 @@ impl TaprootSpendInfo {
// Choose the smallest one amongst the multiple script maps
let smallest = merkle_branch_set
.iter()
.min_by(|x, y| x.0.len().cmp(&y.0.len()))
.min_by(|x, y| x.len().cmp(&y.len()))
.expect("Invariant: ScriptBuf map key must contain non-empty set value");
Some(ControlBlock {
internal_key: self.internal_key,
@ -963,19 +966,19 @@ pub struct LeafNode {
impl LeafNode {
/// Creates an new [`ScriptLeaf`] from `script` and `ver` and no merkle branch.
pub fn new_script(script: ScriptBuf, ver: LeafVersion) -> Self {
Self { leaf: TapLeaf::Script(script, ver), merkle_branch: TaprootMerkleBranch(vec![]) }
Self { leaf: TapLeaf::Script(script, ver), merkle_branch: Default::default() }
}
/// Creates an new [`ScriptLeaf`] from `hash` and no merkle branch.
pub fn new_hidden(hash: TapNodeHash) -> Self {
Self { leaf: TapLeaf::Hidden(hash), merkle_branch: TaprootMerkleBranch(vec![]) }
Self { leaf: TapLeaf::Hidden(hash), merkle_branch: Default::default() }
}
/// Returns the depth of this script leaf in the tap tree.
#[inline]
pub fn depth(&self) -> u8 {
// Depth is guarded by TAPROOT_CONTROL_MAX_NODE_COUNT.
u8::try_from(self.merkle_branch().0.len()).expect("depth is guaranteed to fit in a u8")
u8::try_from(self.merkle_branch().len()).expect("depth is guaranteed to fit in a u8")
}
/// Computes a leaf hash for this [`ScriptLeaf`] if the leaf is known.
@ -1049,143 +1052,6 @@ impl<'leaf> ScriptLeaf<'leaf> {
}
}
/// The merkle proof for inclusion of a tree in a taptree hash.
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
#[cfg_attr(feature = "serde", serde(into = "Vec<TapNodeHash>"))]
#[cfg_attr(feature = "serde", serde(try_from = "Vec<TapNodeHash>"))]
pub struct TaprootMerkleBranch(Vec<TapNodeHash>);
impl TaprootMerkleBranch {
/// Returns a reference to the inner vector of hashes.
pub fn as_inner(&self) -> &[TapNodeHash] { &self.0 }
/// Returns the number of nodes in this merkle proof.
pub fn len(&self) -> usize { self.0.len() }
/// Checks if this merkle proof is empty.
pub fn is_empty(&self) -> bool { self.0.is_empty() }
/// Decodes bytes from control block.
///
/// This reads the branch as encoded in the control block: the concatenated 32B byte chunks -
/// one for each hash.
///
/// # Errors
///
/// The function returns an error if the the number of bytes is not an integer multiple of 32 or
/// if the number of hashes exceeds 128.
pub fn decode(sl: &[u8]) -> Result<Self, TaprootError> {
if sl.len() % TAPROOT_CONTROL_NODE_SIZE != 0 {
Err(TaprootError::InvalidMerkleBranchSize(sl.len()))
} else if sl.len() > TAPROOT_CONTROL_NODE_SIZE * TAPROOT_CONTROL_MAX_NODE_COUNT {
Err(TaprootError::InvalidMerkleTreeDepth(sl.len() / TAPROOT_CONTROL_NODE_SIZE))
} else {
let inner = sl
.chunks_exact(TAPROOT_CONTROL_NODE_SIZE)
.map(|chunk| {
TapNodeHash::from_slice(chunk)
.expect("chunks_exact always returns the correct size")
})
.collect();
Ok(TaprootMerkleBranch(inner))
}
}
/// Creates a merkle proof from list of hashes.
///
/// # Errors
/// If inner proof length is more than [`TAPROOT_CONTROL_MAX_NODE_COUNT`] (128).
fn from_collection<T: AsRef<[TapNodeHash]> + Into<Vec<TapNodeHash>>>(
collection: T,
) -> Result<Self, TaprootError> {
if collection.as_ref().len() > TAPROOT_CONTROL_MAX_NODE_COUNT {
Err(TaprootError::InvalidMerkleTreeDepth(collection.as_ref().len()))
} else {
Ok(TaprootMerkleBranch(collection.into()))
}
}
/// Serializes to a writer.
///
/// # Returns
///
/// The number of bytes written to the writer.
pub fn encode<Write: io::Write + ?Sized>(&self, writer: &mut Write) -> io::Result<usize> {
for hash in self.0.iter() {
writer.write_all(hash.as_ref())?;
}
Ok(self.0.len() * TapNodeHash::LEN)
}
/// Serializes `self` as bytes.
pub fn serialize(&self) -> Vec<u8> {
self.0.iter().flat_map(|e| e.as_byte_array()).copied().collect::<Vec<u8>>()
}
/// Appends elements to proof.
fn push(&mut self, h: TapNodeHash) -> Result<(), TaprootBuilderError> {
if self.0.len() >= TAPROOT_CONTROL_MAX_NODE_COUNT {
Err(TaprootBuilderError::InvalidMerkleTreeDepth(self.0.len()))
} else {
self.0.push(h);
Ok(())
}
}
/// Returns the inner list of hashes.
pub fn into_inner(self) -> Vec<TapNodeHash> { self.0 }
}
macro_rules! impl_try_from {
($from:ty) => {
impl TryFrom<$from> for TaprootMerkleBranch {
type Error = TaprootError;
/// Creates a merkle proof from list of hashes.
///
/// # Errors
/// If inner proof length is more than [`TAPROOT_CONTROL_MAX_NODE_COUNT`] (128).
fn try_from(v: $from) -> Result<Self, Self::Error> {
TaprootMerkleBranch::from_collection(v)
}
}
};
}
impl_try_from!(&[TapNodeHash]);
impl_try_from!(Vec<TapNodeHash>);
impl_try_from!(Box<[TapNodeHash]>);
macro_rules! impl_try_from_array {
($($len:expr),* $(,)?) => {
$(
impl From<[TapNodeHash; $len]> for TaprootMerkleBranch {
fn from(a: [TapNodeHash; $len]) -> Self {
Self(a.to_vec())
}
}
)*
}
}
// Implement for all values [0, 128] inclusive.
//
// The reason zero is included is that `TaprootMerkleBranch` doesn't contain the hash of the node
// that's being proven - it's not needed because the script is already right before control block.
impl_try_from_array!(
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128
);
impl From<TaprootMerkleBranch> for Vec<TapNodeHash> {
fn from(branch: TaprootMerkleBranch) -> Self { branch.0 }
}
/// Control block data structure used in Tapscript satisfaction.
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@ -1235,7 +1101,7 @@ impl ControlBlock {
/// Returns the size of control block. Faster and more efficient than calling
/// `Self::serialize().len()`. Can be handy for fee estimation.
pub fn size(&self) -> usize {
TAPROOT_CONTROL_BASE_SIZE + TAPROOT_CONTROL_NODE_SIZE * self.merkle_branch.as_inner().len()
TAPROOT_CONTROL_BASE_SIZE + TAPROOT_CONTROL_NODE_SIZE * self.merkle_branch.len()
}
/// Serializes to a writer.
@ -1277,7 +1143,7 @@ impl ControlBlock {
// Initially the curr_hash is the leaf hash
let mut curr_hash = TapNodeHash::from_script(script, self.leaf_version);
// Verify the proof
for elem in self.merkle_branch.as_inner() {
for elem in &self.merkle_branch {
// Recalculate the curr hash as parent hash
curr_hash = TapNodeHash::from_node_hashes(curr_hash, *elem);
}
@ -1760,7 +1626,6 @@ mod test {
.iter()
.next()
.expect("Present Path")
.0
.len()
);
}
@ -1874,7 +1739,7 @@ mod test {
let hash1 = TapNodeHash::from_slice(&dummy_hash).unwrap();
let dummy_hash = hex!("8d79dedc2fa0b55167b5d28c61dbad9ce1191a433f3a1a6c8ee291631b2c94c9");
let hash2 = TapNodeHash::from_slice(&dummy_hash).unwrap();
let merkle_branch = TaprootMerkleBranch::from_collection(vec![hash1, hash2]).unwrap();
let merkle_branch = TaprootMerkleBranch::from([hash1, hash2]);
// use serde_test to test serialization and deserialization
serde_test::assert_tokens(
&merkle_branch.readable(),