fix: rm duplicate bdk_tmp_plan module
This commit is contained in:
志宇
parent
af705da1a8
commit
315e7e0b4b
@ -1,13 +0,0 @@
|
|||||||
[package]
|
|
||||||
name = "bdk_tmp_plan"
|
|
||||||
version = "0.1.0"
|
|
||||||
edition = "2021"
|
|
||||||
|
|
||||||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
|
||||||
|
|
||||||
[dependencies]
|
|
||||||
bdk_chain = { path = "../../../crates/chain", version = "0.3.1", features = ["miniscript"] }
|
|
||||||
|
|
||||||
[features]
|
|
||||||
default = ["std"]
|
|
||||||
std = []
|
|
||||||
@ -1,3 +0,0 @@
|
|||||||
# Temporary planning module
|
|
||||||
|
|
||||||
A temporary place to hold the planning module until https://github.com/rust-bitcoin/rust-miniscript/pull/481 is merged and released
|
|
||||||
@ -1,436 +0,0 @@
|
|||||||
#![allow(unused)]
|
|
||||||
#![allow(missing_docs)]
|
|
||||||
//! A spending plan or *plan* for short is a representation of a particular spending path on a
|
|
||||||
//! descriptor. This allows us to analayze a choice of spending path without producing any
|
|
||||||
//! signatures or other witness data for it.
|
|
||||||
//!
|
|
||||||
//! To make a plan you provide the descriptor with "assets" like which keys you are able to use, hash
|
|
||||||
//! pre-images you have access to, the current block height etc.
|
|
||||||
//!
|
|
||||||
//! Once you've got a plan it can tell you its expected satisfaction weight which can be useful for
|
|
||||||
//! doing coin selection. Furthermore it provides which subset of those keys and hash pre-images you
|
|
||||||
//! will actually need as well as what locktime or sequence number you need to set.
|
|
||||||
//!
|
|
||||||
//! Once you've obstained signatures, hash pre-images etc required by the plan, it can create a
|
|
||||||
//! witness/script_sig for the input.
|
|
||||||
use bdk_chain::{bitcoin, collections::*, miniscript};
|
|
||||||
use bitcoin::{
|
|
||||||
blockdata::{locktime::LockTime, transaction::Sequence},
|
|
||||||
hashes::{hash160, ripemd160, sha256},
|
|
||||||
secp256k1::Secp256k1,
|
|
||||||
util::{
|
|
||||||
address::WitnessVersion,
|
|
||||||
bip32::{DerivationPath, Fingerprint, KeySource},
|
|
||||||
taproot::{LeafVersion, TapBranchHash, TapLeafHash},
|
|
||||||
},
|
|
||||||
EcdsaSig, SchnorrSig, Script, TxIn, Witness,
|
|
||||||
};
|
|
||||||
use miniscript::{
|
|
||||||
descriptor::{InnerXKey, Tr},
|
|
||||||
hash256, DefiniteDescriptorKey, Descriptor, DescriptorPublicKey, ScriptContext, ToPublicKey,
|
|
||||||
};
|
|
||||||
|
|
||||||
pub(crate) fn varint_len(v: usize) -> usize {
|
|
||||||
bitcoin::VarInt(v as u64).len() as usize
|
|
||||||
}
|
|
||||||
|
|
||||||
mod plan_impls;
|
|
||||||
mod requirements;
|
|
||||||
mod template;
|
|
||||||
pub use requirements::*;
|
|
||||||
pub use template::PlanKey;
|
|
||||||
use template::TemplateItem;
|
|
||||||
|
|
||||||
#[derive(Clone, Debug)]
|
|
||||||
enum TrSpend {
|
|
||||||
KeySpend,
|
|
||||||
LeafSpend {
|
|
||||||
script: Script,
|
|
||||||
leaf_version: LeafVersion,
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Clone, Debug)]
|
|
||||||
enum Target {
|
|
||||||
Legacy,
|
|
||||||
Segwitv0 {
|
|
||||||
script_code: Script,
|
|
||||||
},
|
|
||||||
Segwitv1 {
|
|
||||||
tr: Tr<DefiniteDescriptorKey>,
|
|
||||||
tr_plan: TrSpend,
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Target {}
|
|
||||||
|
|
||||||
#[derive(Clone, Debug)]
|
|
||||||
/// A plan represents a particular spending path for a descriptor.
|
|
||||||
///
|
|
||||||
/// See the module level documentation for more info.
|
|
||||||
pub struct Plan<AK> {
|
|
||||||
template: Vec<TemplateItem<AK>>,
|
|
||||||
target: Target,
|
|
||||||
set_locktime: Option<LockTime>,
|
|
||||||
set_sequence: Option<Sequence>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Default for Target {
|
|
||||||
fn default() -> Self {
|
|
||||||
Target::Legacy
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Clone, Debug, Default)]
|
|
||||||
/// Signatures and hash pre-images that can be used to complete a plan.
|
|
||||||
pub struct SatisfactionMaterial {
|
|
||||||
/// Schnorr signautres under their keys
|
|
||||||
pub schnorr_sigs: BTreeMap<DefiniteDescriptorKey, SchnorrSig>,
|
|
||||||
/// ECDSA signatures under their keys
|
|
||||||
pub ecdsa_sigs: BTreeMap<DefiniteDescriptorKey, EcdsaSig>,
|
|
||||||
/// SHA256 pre-images under their images
|
|
||||||
pub sha256_preimages: BTreeMap<sha256::Hash, Vec<u8>>,
|
|
||||||
/// hash160 pre-images under their images
|
|
||||||
pub hash160_preimages: BTreeMap<hash160::Hash, Vec<u8>>,
|
|
||||||
/// hash256 pre-images under their images
|
|
||||||
pub hash256_preimages: BTreeMap<hash256::Hash, Vec<u8>>,
|
|
||||||
/// ripemd160 pre-images under their images
|
|
||||||
pub ripemd160_preimages: BTreeMap<ripemd160::Hash, Vec<u8>>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<Ak> Plan<Ak>
|
|
||||||
where
|
|
||||||
Ak: Clone,
|
|
||||||
{
|
|
||||||
/// The expected satisfaction weight for the plan if it is completed.
|
|
||||||
pub fn expected_weight(&self) -> usize {
|
|
||||||
let script_sig_size = match self.target {
|
|
||||||
Target::Legacy => unimplemented!(), // self
|
|
||||||
// .template
|
|
||||||
// .iter()
|
|
||||||
// .map(|step| {
|
|
||||||
// let size = step.expected_size();
|
|
||||||
// size + push_opcode_size(size)
|
|
||||||
// })
|
|
||||||
// .sum()
|
|
||||||
Target::Segwitv0 { .. } | Target::Segwitv1 { .. } => 1,
|
|
||||||
};
|
|
||||||
let witness_elem_sizes: Option<Vec<usize>> = match &self.target {
|
|
||||||
Target::Legacy => None,
|
|
||||||
Target::Segwitv0 { .. } => Some(
|
|
||||||
self.template
|
|
||||||
.iter()
|
|
||||||
.map(|step| step.expected_size())
|
|
||||||
.collect(),
|
|
||||||
),
|
|
||||||
Target::Segwitv1 { tr, tr_plan } => {
|
|
||||||
let mut witness_elems = self
|
|
||||||
.template
|
|
||||||
.iter()
|
|
||||||
.map(|step| step.expected_size())
|
|
||||||
.collect::<Vec<_>>();
|
|
||||||
|
|
||||||
if let TrSpend::LeafSpend {
|
|
||||||
script,
|
|
||||||
leaf_version,
|
|
||||||
} = tr_plan
|
|
||||||
{
|
|
||||||
let control_block = tr
|
|
||||||
.spend_info()
|
|
||||||
.control_block(&(script.clone(), *leaf_version))
|
|
||||||
.expect("must exist");
|
|
||||||
witness_elems.push(script.len());
|
|
||||||
witness_elems.push(control_block.size());
|
|
||||||
}
|
|
||||||
|
|
||||||
Some(witness_elems)
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
let witness_size: usize = match witness_elem_sizes {
|
|
||||||
Some(elems) => {
|
|
||||||
varint_len(elems.len())
|
|
||||||
+ elems
|
|
||||||
.into_iter()
|
|
||||||
.map(|elem| varint_len(elem) + elem)
|
|
||||||
.sum::<usize>()
|
|
||||||
}
|
|
||||||
None => 0,
|
|
||||||
};
|
|
||||||
|
|
||||||
script_sig_size * 4 + witness_size
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn requirements(&self) -> Requirements<Ak> {
|
|
||||||
match self.try_complete(&SatisfactionMaterial::default()) {
|
|
||||||
PlanState::Complete { .. } => Requirements::default(),
|
|
||||||
PlanState::Incomplete(requirements) => requirements,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn try_complete(&self, auth_data: &SatisfactionMaterial) -> PlanState<Ak> {
|
|
||||||
let unsatisfied_items = self
|
|
||||||
.template
|
|
||||||
.iter()
|
|
||||||
.filter(|step| match step {
|
|
||||||
TemplateItem::Sign(key) => {
|
|
||||||
!auth_data.schnorr_sigs.contains_key(&key.descriptor_key)
|
|
||||||
}
|
|
||||||
TemplateItem::Hash160(image) => !auth_data.hash160_preimages.contains_key(image),
|
|
||||||
TemplateItem::Hash256(image) => !auth_data.hash256_preimages.contains_key(image),
|
|
||||||
TemplateItem::Sha256(image) => !auth_data.sha256_preimages.contains_key(image),
|
|
||||||
TemplateItem::Ripemd160(image) => {
|
|
||||||
!auth_data.ripemd160_preimages.contains_key(image)
|
|
||||||
}
|
|
||||||
TemplateItem::Pk { .. } | TemplateItem::One | TemplateItem::Zero => false,
|
|
||||||
})
|
|
||||||
.collect::<Vec<_>>();
|
|
||||||
|
|
||||||
if unsatisfied_items.is_empty() {
|
|
||||||
let mut witness = self
|
|
||||||
.template
|
|
||||||
.iter()
|
|
||||||
.flat_map(|step| step.to_witness_stack(&auth_data))
|
|
||||||
.collect::<Vec<_>>();
|
|
||||||
match &self.target {
|
|
||||||
Target::Segwitv0 { .. } => todo!(),
|
|
||||||
Target::Legacy => todo!(),
|
|
||||||
Target::Segwitv1 {
|
|
||||||
tr_plan: TrSpend::KeySpend,
|
|
||||||
..
|
|
||||||
} => PlanState::Complete {
|
|
||||||
final_script_sig: None,
|
|
||||||
final_script_witness: Some(Witness::from_vec(witness)),
|
|
||||||
},
|
|
||||||
Target::Segwitv1 {
|
|
||||||
tr,
|
|
||||||
tr_plan:
|
|
||||||
TrSpend::LeafSpend {
|
|
||||||
script,
|
|
||||||
leaf_version,
|
|
||||||
},
|
|
||||||
} => {
|
|
||||||
let spend_info = tr.spend_info();
|
|
||||||
let control_block = spend_info
|
|
||||||
.control_block(&(script.clone(), *leaf_version))
|
|
||||||
.expect("must exist");
|
|
||||||
witness.push(script.clone().into_bytes());
|
|
||||||
witness.push(control_block.serialize());
|
|
||||||
|
|
||||||
PlanState::Complete {
|
|
||||||
final_script_sig: None,
|
|
||||||
final_script_witness: Some(Witness::from_vec(witness)),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
let mut requirements = Requirements::default();
|
|
||||||
|
|
||||||
match &self.target {
|
|
||||||
Target::Legacy => {
|
|
||||||
todo!()
|
|
||||||
}
|
|
||||||
Target::Segwitv0 { .. } => {
|
|
||||||
todo!()
|
|
||||||
}
|
|
||||||
Target::Segwitv1 { tr, tr_plan } => {
|
|
||||||
let spend_info = tr.spend_info();
|
|
||||||
match tr_plan {
|
|
||||||
TrSpend::KeySpend => match &self.template[..] {
|
|
||||||
[TemplateItem::Sign(ref plan_key)] => {
|
|
||||||
requirements.signatures = RequiredSignatures::TapKey {
|
|
||||||
merkle_root: spend_info.merkle_root(),
|
|
||||||
plan_key: plan_key.clone(),
|
|
||||||
};
|
|
||||||
}
|
|
||||||
_ => unreachable!("tapkey spend will always have only one sign step"),
|
|
||||||
},
|
|
||||||
TrSpend::LeafSpend {
|
|
||||||
script,
|
|
||||||
leaf_version,
|
|
||||||
} => {
|
|
||||||
let leaf_hash = TapLeafHash::from_script(&script, *leaf_version);
|
|
||||||
requirements.signatures = RequiredSignatures::TapScript {
|
|
||||||
leaf_hash,
|
|
||||||
plan_keys: vec![],
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
let required_signatures = match requirements.signatures {
|
|
||||||
RequiredSignatures::Legacy { .. } => todo!(),
|
|
||||||
RequiredSignatures::Segwitv0 { .. } => todo!(),
|
|
||||||
RequiredSignatures::TapKey { .. } => return PlanState::Incomplete(requirements),
|
|
||||||
RequiredSignatures::TapScript {
|
|
||||||
plan_keys: ref mut keys,
|
|
||||||
..
|
|
||||||
} => keys,
|
|
||||||
};
|
|
||||||
|
|
||||||
for step in unsatisfied_items {
|
|
||||||
match step {
|
|
||||||
TemplateItem::Sign(plan_key) => {
|
|
||||||
required_signatures.push(plan_key.clone());
|
|
||||||
}
|
|
||||||
TemplateItem::Hash160(image) => {
|
|
||||||
requirements.hash160_images.insert(image.clone());
|
|
||||||
}
|
|
||||||
TemplateItem::Hash256(image) => {
|
|
||||||
requirements.hash256_images.insert(image.clone());
|
|
||||||
}
|
|
||||||
TemplateItem::Sha256(image) => {
|
|
||||||
requirements.sha256_images.insert(image.clone());
|
|
||||||
}
|
|
||||||
TemplateItem::Ripemd160(image) => {
|
|
||||||
requirements.ripemd160_images.insert(image.clone());
|
|
||||||
}
|
|
||||||
TemplateItem::Pk { .. } | TemplateItem::One | TemplateItem::Zero => { /* no requirements */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
PlanState::Incomplete(requirements)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Witness version for the plan
|
|
||||||
pub fn witness_version(&self) -> Option<WitnessVersion> {
|
|
||||||
match self.target {
|
|
||||||
Target::Legacy => None,
|
|
||||||
Target::Segwitv0 { .. } => Some(WitnessVersion::V0),
|
|
||||||
Target::Segwitv1 { .. } => Some(WitnessVersion::V1),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// The minimum required locktime height or time on the transaction using the plan.
|
|
||||||
pub fn required_locktime(&self) -> Option<LockTime> {
|
|
||||||
self.set_locktime.clone()
|
|
||||||
}
|
|
||||||
|
|
||||||
/// The minimum required sequence (height or time) on the input to satisfy the plan
|
|
||||||
pub fn required_sequence(&self) -> Option<Sequence> {
|
|
||||||
self.set_sequence.clone()
|
|
||||||
}
|
|
||||||
|
|
||||||
/// The minmum required transaction version required on the transaction using the plan.
|
|
||||||
pub fn min_version(&self) -> Option<u32> {
|
|
||||||
if let Some(_) = self.set_sequence {
|
|
||||||
Some(2)
|
|
||||||
} else {
|
|
||||||
Some(1)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// The returned value from [`Plan::try_complete`].
|
|
||||||
pub enum PlanState<Ak> {
|
|
||||||
/// The plan is complete
|
|
||||||
Complete {
|
|
||||||
/// The script sig that should be set on the input
|
|
||||||
final_script_sig: Option<Script>,
|
|
||||||
/// The witness that should be set on the input
|
|
||||||
final_script_witness: Option<Witness>,
|
|
||||||
},
|
|
||||||
Incomplete(Requirements<Ak>),
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Clone, Debug)]
|
|
||||||
pub struct Assets<K> {
|
|
||||||
pub keys: Vec<K>,
|
|
||||||
pub txo_age: Option<Sequence>,
|
|
||||||
pub max_locktime: Option<LockTime>,
|
|
||||||
pub sha256: Vec<sha256::Hash>,
|
|
||||||
pub hash256: Vec<hash256::Hash>,
|
|
||||||
pub ripemd160: Vec<ripemd160::Hash>,
|
|
||||||
pub hash160: Vec<hash160::Hash>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<K> Default for Assets<K> {
|
|
||||||
fn default() -> Self {
|
|
||||||
Self {
|
|
||||||
keys: Default::default(),
|
|
||||||
txo_age: Default::default(),
|
|
||||||
max_locktime: Default::default(),
|
|
||||||
sha256: Default::default(),
|
|
||||||
hash256: Default::default(),
|
|
||||||
ripemd160: Default::default(),
|
|
||||||
hash160: Default::default(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub trait CanDerive {
|
|
||||||
fn can_derive(&self, key: &DefiniteDescriptorKey) -> Option<DerivationPath>;
|
|
||||||
}
|
|
||||||
|
|
||||||
impl CanDerive for KeySource {
|
|
||||||
fn can_derive(&self, key: &DefiniteDescriptorKey) -> Option<DerivationPath> {
|
|
||||||
match DescriptorPublicKey::from(key.clone()) {
|
|
||||||
DescriptorPublicKey::Single(single_pub) => {
|
|
||||||
path_to_child(self, single_pub.origin.as_ref()?, None)
|
|
||||||
}
|
|
||||||
DescriptorPublicKey::XPub(dxk) => {
|
|
||||||
let origin = dxk.origin.clone().unwrap_or_else(|| {
|
|
||||||
let secp = Secp256k1::signing_only();
|
|
||||||
(dxk.xkey.xkey_fingerprint(&secp), DerivationPath::master())
|
|
||||||
});
|
|
||||||
|
|
||||||
path_to_child(self, &origin, Some(&dxk.derivation_path))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl CanDerive for DescriptorPublicKey {
|
|
||||||
fn can_derive(&self, key: &DefiniteDescriptorKey) -> Option<DerivationPath> {
|
|
||||||
match (self, DescriptorPublicKey::from(key.clone())) {
|
|
||||||
(parent, child) if parent == &child => Some(DerivationPath::master()),
|
|
||||||
(DescriptorPublicKey::XPub(parent), _) => {
|
|
||||||
let origin = parent.origin.clone().unwrap_or_else(|| {
|
|
||||||
let secp = Secp256k1::signing_only();
|
|
||||||
(
|
|
||||||
parent.xkey.xkey_fingerprint(&secp),
|
|
||||||
DerivationPath::master(),
|
|
||||||
)
|
|
||||||
});
|
|
||||||
KeySource::from(origin).can_derive(key)
|
|
||||||
}
|
|
||||||
_ => None,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn path_to_child(
|
|
||||||
parent: &KeySource,
|
|
||||||
child_origin: &(Fingerprint, DerivationPath),
|
|
||||||
child_derivation: Option<&DerivationPath>,
|
|
||||||
) -> Option<DerivationPath> {
|
|
||||||
if parent.0 == child_origin.0 {
|
|
||||||
let mut remaining_derivation =
|
|
||||||
DerivationPath::from(child_origin.1[..].strip_prefix(&parent.1[..])?);
|
|
||||||
remaining_derivation =
|
|
||||||
remaining_derivation.extend(child_derivation.unwrap_or(&DerivationPath::master()));
|
|
||||||
Some(remaining_derivation)
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn plan_satisfaction<Ak>(
|
|
||||||
desc: &Descriptor<DefiniteDescriptorKey>,
|
|
||||||
assets: &Assets<Ak>,
|
|
||||||
) -> Option<Plan<Ak>>
|
|
||||||
where
|
|
||||||
Ak: CanDerive + Clone,
|
|
||||||
{
|
|
||||||
match desc {
|
|
||||||
Descriptor::Bare(_) => todo!(),
|
|
||||||
Descriptor::Pkh(_) => todo!(),
|
|
||||||
Descriptor::Wpkh(_) => todo!(),
|
|
||||||
Descriptor::Sh(_) => todo!(),
|
|
||||||
Descriptor::Wsh(_) => todo!(),
|
|
||||||
Descriptor::Tr(tr) => crate::plan_impls::plan_satisfaction_tr(tr, assets),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,323 +0,0 @@
|
|||||||
use bdk_chain::{bitcoin, miniscript};
|
|
||||||
use bitcoin::locktime::{Height, Time};
|
|
||||||
use miniscript::Terminal;
|
|
||||||
|
|
||||||
use super::*;
|
|
||||||
|
|
||||||
impl<Ak> TermPlan<Ak> {
|
|
||||||
fn combine(self, other: Self) -> Option<Self> {
|
|
||||||
let min_locktime = {
|
|
||||||
match (self.min_locktime, other.min_locktime) {
|
|
||||||
(Some(lhs), Some(rhs)) => {
|
|
||||||
if lhs.is_same_unit(rhs) {
|
|
||||||
Some(if lhs.to_consensus_u32() > rhs.to_consensus_u32() {
|
|
||||||
lhs
|
|
||||||
} else {
|
|
||||||
rhs
|
|
||||||
})
|
|
||||||
} else {
|
|
||||||
return None;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
_ => self.min_locktime.or(other.min_locktime),
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
let min_sequence = {
|
|
||||||
match (self.min_sequence, other.min_sequence) {
|
|
||||||
(Some(lhs), Some(rhs)) => {
|
|
||||||
if lhs.is_height_locked() == rhs.is_height_locked() {
|
|
||||||
Some(if lhs.to_consensus_u32() > rhs.to_consensus_u32() {
|
|
||||||
lhs
|
|
||||||
} else {
|
|
||||||
rhs
|
|
||||||
})
|
|
||||||
} else {
|
|
||||||
return None;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
_ => self.min_sequence.or(other.min_sequence),
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
let mut template = self.template;
|
|
||||||
template.extend(other.template);
|
|
||||||
|
|
||||||
Some(Self {
|
|
||||||
min_locktime,
|
|
||||||
min_sequence,
|
|
||||||
template,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
pub(crate) fn expected_size(&self) -> usize {
|
|
||||||
self.template.iter().map(|step| step.expected_size()).sum()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// impl crate::descriptor::Pkh<DefiniteDescriptorKey> {
|
|
||||||
// pub(crate) fn plan_satisfaction<Ak>(&self, assets: &Assets<Ak>) -> Option<Plan<Ak>>
|
|
||||||
// where
|
|
||||||
// Ak: CanDerive + Clone,
|
|
||||||
// {
|
|
||||||
// let (asset_key, derivation_hint) = assets.keys.iter().find_map(|asset_key| {
|
|
||||||
// let derivation_hint = asset_key.can_derive(self.as_inner())?;
|
|
||||||
// Some((asset_key, derivation_hint))
|
|
||||||
// })?;
|
|
||||||
|
|
||||||
// Some(Plan {
|
|
||||||
// template: vec![TemplateItem::Sign(PlanKey {
|
|
||||||
// asset_key: asset_key.clone(),
|
|
||||||
// descriptor_key: self.as_inner().clone(),
|
|
||||||
// derivation_hint,
|
|
||||||
// })],
|
|
||||||
// target: Target::Legacy,
|
|
||||||
// set_locktime: None,
|
|
||||||
// set_sequence: None,
|
|
||||||
// })
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
|
|
||||||
// impl crate::descriptor::Wpkh<DefiniteDescriptorKey> {
|
|
||||||
// pub(crate) fn plan_satisfaction<Ak>(&self, assets: &Assets<Ak>) -> Option<Plan<Ak>>
|
|
||||||
// where
|
|
||||||
// Ak: CanDerive + Clone,
|
|
||||||
// {
|
|
||||||
// let (asset_key, derivation_hint) = assets.keys.iter().find_map(|asset_key| {
|
|
||||||
// let derivation_hint = asset_key.can_derive(self.as_inner())?;
|
|
||||||
// Some((asset_key, derivation_hint))
|
|
||||||
// })?;
|
|
||||||
|
|
||||||
// Some(Plan {
|
|
||||||
// template: vec![TemplateItem::Sign(PlanKey {
|
|
||||||
// asset_key: asset_key.clone(),
|
|
||||||
// descriptor_key: self.as_inner().clone(),
|
|
||||||
// derivation_hint,
|
|
||||||
// })],
|
|
||||||
// target: Target::Segwitv0,
|
|
||||||
// set_locktime: None,
|
|
||||||
// set_sequence: None,
|
|
||||||
// })
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
|
|
||||||
pub(crate) fn plan_satisfaction_tr<Ak>(
|
|
||||||
tr: &miniscript::descriptor::Tr<DefiniteDescriptorKey>,
|
|
||||||
assets: &Assets<Ak>,
|
|
||||||
) -> Option<Plan<Ak>>
|
|
||||||
where
|
|
||||||
Ak: CanDerive + Clone,
|
|
||||||
{
|
|
||||||
let key_path_spend = assets.keys.iter().find_map(|asset_key| {
|
|
||||||
let derivation_hint = asset_key.can_derive(tr.internal_key())?;
|
|
||||||
Some((asset_key, derivation_hint))
|
|
||||||
});
|
|
||||||
|
|
||||||
if let Some((asset_key, derivation_hint)) = key_path_spend {
|
|
||||||
return Some(Plan {
|
|
||||||
template: vec![TemplateItem::Sign(PlanKey {
|
|
||||||
asset_key: asset_key.clone(),
|
|
||||||
descriptor_key: tr.internal_key().clone(),
|
|
||||||
derivation_hint,
|
|
||||||
})],
|
|
||||||
target: Target::Segwitv1 {
|
|
||||||
tr: tr.clone(),
|
|
||||||
tr_plan: TrSpend::KeySpend,
|
|
||||||
},
|
|
||||||
set_locktime: None,
|
|
||||||
set_sequence: None,
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
let mut plans = tr
|
|
||||||
.iter_scripts()
|
|
||||||
.filter_map(|(_, ms)| Some((ms, (plan_steps(&ms.node, assets)?))))
|
|
||||||
.collect::<Vec<_>>();
|
|
||||||
|
|
||||||
plans.sort_by_cached_key(|(_, plan)| plan.expected_size());
|
|
||||||
|
|
||||||
let (script, best_plan) = plans.into_iter().next()?;
|
|
||||||
|
|
||||||
Some(Plan {
|
|
||||||
target: Target::Segwitv1 {
|
|
||||||
tr: tr.clone(),
|
|
||||||
tr_plan: TrSpend::LeafSpend {
|
|
||||||
script: script.encode(),
|
|
||||||
leaf_version: LeafVersion::TapScript,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
set_locktime: best_plan.min_locktime.clone(),
|
|
||||||
set_sequence: best_plan.min_sequence.clone(),
|
|
||||||
template: best_plan.template,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Debug)]
|
|
||||||
struct TermPlan<Ak> {
|
|
||||||
pub min_locktime: Option<LockTime>,
|
|
||||||
pub min_sequence: Option<Sequence>,
|
|
||||||
pub template: Vec<TemplateItem<Ak>>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<Ak> TermPlan<Ak> {
|
|
||||||
fn new(template: Vec<TemplateItem<Ak>>) -> Self {
|
|
||||||
TermPlan {
|
|
||||||
template,
|
|
||||||
..Default::default()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<Ak> Default for TermPlan<Ak> {
|
|
||||||
fn default() -> Self {
|
|
||||||
Self {
|
|
||||||
min_locktime: Default::default(),
|
|
||||||
min_sequence: Default::default(),
|
|
||||||
template: Default::default(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn plan_steps<Ak: Clone + CanDerive, Ctx: ScriptContext>(
|
|
||||||
term: &Terminal<DefiniteDescriptorKey, Ctx>,
|
|
||||||
assets: &Assets<Ak>,
|
|
||||||
) -> Option<TermPlan<Ak>> {
|
|
||||||
match term {
|
|
||||||
Terminal::True => Some(TermPlan::new(vec![])),
|
|
||||||
Terminal::False => return None,
|
|
||||||
Terminal::PkH(key) => {
|
|
||||||
let (asset_key, derivation_hint) = assets
|
|
||||||
.keys
|
|
||||||
.iter()
|
|
||||||
.find_map(|asset_key| Some((asset_key, asset_key.can_derive(key)?)))?;
|
|
||||||
Some(TermPlan::new(vec![
|
|
||||||
TemplateItem::Sign(PlanKey {
|
|
||||||
asset_key: asset_key.clone(),
|
|
||||||
derivation_hint,
|
|
||||||
descriptor_key: key.clone(),
|
|
||||||
}),
|
|
||||||
TemplateItem::Pk { key: key.clone() },
|
|
||||||
]))
|
|
||||||
}
|
|
||||||
Terminal::PkK(key) => {
|
|
||||||
let (asset_key, derivation_hint) = assets
|
|
||||||
.keys
|
|
||||||
.iter()
|
|
||||||
.find_map(|asset_key| Some((asset_key, asset_key.can_derive(key)?)))?;
|
|
||||||
Some(TermPlan::new(vec![TemplateItem::Sign(PlanKey {
|
|
||||||
asset_key: asset_key.clone(),
|
|
||||||
derivation_hint,
|
|
||||||
descriptor_key: key.clone(),
|
|
||||||
})]))
|
|
||||||
}
|
|
||||||
Terminal::RawPkH(_pk_hash) => {
|
|
||||||
/* TODO */
|
|
||||||
None
|
|
||||||
}
|
|
||||||
Terminal::After(locktime) => {
|
|
||||||
let max_locktime = assets.max_locktime?;
|
|
||||||
let locktime = LockTime::from(locktime);
|
|
||||||
let (height, time) = match max_locktime {
|
|
||||||
LockTime::Blocks(height) => (height, Time::from_consensus(0).unwrap()),
|
|
||||||
LockTime::Seconds(seconds) => (Height::from_consensus(0).unwrap(), seconds),
|
|
||||||
};
|
|
||||||
if max_locktime.is_satisfied_by(height, time) {
|
|
||||||
Some(TermPlan {
|
|
||||||
min_locktime: Some(locktime),
|
|
||||||
..Default::default()
|
|
||||||
})
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Terminal::Older(older) => {
|
|
||||||
// FIXME: older should be a height or time not a sequence.
|
|
||||||
let max_sequence = assets.txo_age?;
|
|
||||||
//TODO: this whole thing is probably wrong but upstream should provide a way of
|
|
||||||
// doing it properly.
|
|
||||||
if max_sequence.is_height_locked() == older.is_height_locked() {
|
|
||||||
if max_sequence.to_consensus_u32() >= older.to_consensus_u32() {
|
|
||||||
Some(TermPlan {
|
|
||||||
min_sequence: Some(*older),
|
|
||||||
..Default::default()
|
|
||||||
})
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Terminal::Sha256(image) => {
|
|
||||||
if assets.sha256.contains(&image) {
|
|
||||||
Some(TermPlan::new(vec![TemplateItem::Sha256(image.clone())]))
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Terminal::Hash256(image) => {
|
|
||||||
if assets.hash256.contains(image) {
|
|
||||||
Some(TermPlan::new(vec![TemplateItem::Hash256(image.clone())]))
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Terminal::Ripemd160(image) => {
|
|
||||||
if assets.ripemd160.contains(&image) {
|
|
||||||
Some(TermPlan::new(vec![TemplateItem::Ripemd160(image.clone())]))
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Terminal::Hash160(image) => {
|
|
||||||
if assets.hash160.contains(&image) {
|
|
||||||
Some(TermPlan::new(vec![TemplateItem::Hash160(image.clone())]))
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Terminal::Alt(ms)
|
|
||||||
| Terminal::Swap(ms)
|
|
||||||
| Terminal::Check(ms)
|
|
||||||
| Terminal::Verify(ms)
|
|
||||||
| Terminal::NonZero(ms)
|
|
||||||
| Terminal::ZeroNotEqual(ms) => plan_steps(&ms.node, assets),
|
|
||||||
Terminal::DupIf(ms) => {
|
|
||||||
let mut plan = plan_steps(&ms.node, assets)?;
|
|
||||||
plan.template.push(TemplateItem::One);
|
|
||||||
Some(plan)
|
|
||||||
}
|
|
||||||
Terminal::AndV(l, r) | Terminal::AndB(l, r) => {
|
|
||||||
let lhs = plan_steps(&l.node, assets)?;
|
|
||||||
let rhs = plan_steps(&r.node, assets)?;
|
|
||||||
lhs.combine(rhs)
|
|
||||||
}
|
|
||||||
Terminal::AndOr(_, _, _) => todo!(),
|
|
||||||
Terminal::OrB(_, _) => todo!(),
|
|
||||||
Terminal::OrD(_, _) => todo!(),
|
|
||||||
Terminal::OrC(_, _) => todo!(),
|
|
||||||
Terminal::OrI(lhs, rhs) => {
|
|
||||||
let lplan = plan_steps(&lhs.node, assets).map(|mut plan| {
|
|
||||||
plan.template.push(TemplateItem::One);
|
|
||||||
plan
|
|
||||||
});
|
|
||||||
let rplan = plan_steps(&rhs.node, assets).map(|mut plan| {
|
|
||||||
plan.template.push(TemplateItem::Zero);
|
|
||||||
plan
|
|
||||||
});
|
|
||||||
match (lplan, rplan) {
|
|
||||||
(Some(lplan), Some(rplan)) => {
|
|
||||||
if lplan.expected_size() <= rplan.expected_size() {
|
|
||||||
Some(lplan)
|
|
||||||
} else {
|
|
||||||
Some(rplan)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
(lplan, rplan) => lplan.or(rplan),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Terminal::Thresh(_, _) => todo!(),
|
|
||||||
Terminal::Multi(_, _) => todo!(),
|
|
||||||
Terminal::MultiA(_, _) => todo!(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,218 +0,0 @@
|
|||||||
use bdk_chain::{bitcoin, collections::*, miniscript};
|
|
||||||
use core::ops::Deref;
|
|
||||||
|
|
||||||
use bitcoin::{
|
|
||||||
hashes::{hash160, ripemd160, sha256},
|
|
||||||
psbt::Prevouts,
|
|
||||||
secp256k1::{KeyPair, Message, PublicKey, Signing, Verification},
|
|
||||||
util::{bip32, sighash, sighash::SighashCache, taproot},
|
|
||||||
EcdsaSighashType, SchnorrSighashType, Transaction, TxOut, XOnlyPublicKey,
|
|
||||||
};
|
|
||||||
|
|
||||||
use super::*;
|
|
||||||
use miniscript::{
|
|
||||||
descriptor::{DescriptorSecretKey, KeyMap},
|
|
||||||
hash256,
|
|
||||||
};
|
|
||||||
|
|
||||||
#[derive(Clone, Debug)]
|
|
||||||
/// Signatures and hash pre-images that must be provided to complete the plan.
|
|
||||||
pub struct Requirements<Ak> {
|
|
||||||
/// required signatures
|
|
||||||
pub signatures: RequiredSignatures<Ak>,
|
|
||||||
/// required sha256 pre-images
|
|
||||||
pub sha256_images: HashSet<sha256::Hash>,
|
|
||||||
/// required hash160 pre-images
|
|
||||||
pub hash160_images: HashSet<hash160::Hash>,
|
|
||||||
/// required hash256 pre-images
|
|
||||||
pub hash256_images: HashSet<hash256::Hash>,
|
|
||||||
/// required ripemd160 pre-images
|
|
||||||
pub ripemd160_images: HashSet<ripemd160::Hash>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<Ak> Default for RequiredSignatures<Ak> {
|
|
||||||
fn default() -> Self {
|
|
||||||
RequiredSignatures::Legacy {
|
|
||||||
keys: Default::default(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<Ak> Default for Requirements<Ak> {
|
|
||||||
fn default() -> Self {
|
|
||||||
Self {
|
|
||||||
signatures: Default::default(),
|
|
||||||
sha256_images: Default::default(),
|
|
||||||
hash160_images: Default::default(),
|
|
||||||
hash256_images: Default::default(),
|
|
||||||
ripemd160_images: Default::default(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<Ak> Requirements<Ak> {
|
|
||||||
/// Whether any hash pre-images are required in the plan
|
|
||||||
pub fn requires_hash_preimages(&self) -> bool {
|
|
||||||
!(self.sha256_images.is_empty()
|
|
||||||
&& self.hash160_images.is_empty()
|
|
||||||
&& self.hash256_images.is_empty()
|
|
||||||
&& self.ripemd160_images.is_empty())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// The signatures required to complete the plan
|
|
||||||
#[derive(Clone, Debug)]
|
|
||||||
pub enum RequiredSignatures<Ak> {
|
|
||||||
/// Legacy ECDSA signatures are required
|
|
||||||
Legacy { keys: Vec<PlanKey<Ak>> },
|
|
||||||
/// Segwitv0 ECDSA signatures are required
|
|
||||||
Segwitv0 { keys: Vec<PlanKey<Ak>> },
|
|
||||||
/// A Taproot key spend signature is required
|
|
||||||
TapKey {
|
|
||||||
/// the internal key
|
|
||||||
plan_key: PlanKey<Ak>,
|
|
||||||
/// The merkle root of the taproot output
|
|
||||||
merkle_root: Option<TapBranchHash>,
|
|
||||||
},
|
|
||||||
/// Taproot script path signatures are required
|
|
||||||
TapScript {
|
|
||||||
/// The leaf hash of the script being used
|
|
||||||
leaf_hash: TapLeafHash,
|
|
||||||
/// The keys in the script that require signatures
|
|
||||||
plan_keys: Vec<PlanKey<Ak>>,
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Clone, Debug)]
|
|
||||||
pub enum SigningError {
|
|
||||||
SigHashError(sighash::Error),
|
|
||||||
DerivationError(bip32::Error),
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<sighash::Error> for SigningError {
|
|
||||||
fn from(e: sighash::Error) -> Self {
|
|
||||||
Self::SigHashError(e)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl core::fmt::Display for SigningError {
|
|
||||||
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
|
|
||||||
match self {
|
|
||||||
SigningError::SigHashError(e) => e.fmt(f),
|
|
||||||
SigningError::DerivationError(e) => e.fmt(f),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<bip32::Error> for SigningError {
|
|
||||||
fn from(e: bip32::Error) -> Self {
|
|
||||||
Self::DerivationError(e)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "std")]
|
|
||||||
impl std::error::Error for SigningError {}
|
|
||||||
|
|
||||||
impl RequiredSignatures<DescriptorPublicKey> {
|
|
||||||
pub fn sign_with_keymap<T: Deref<Target = Transaction>>(
|
|
||||||
&self,
|
|
||||||
input_index: usize,
|
|
||||||
keymap: &KeyMap,
|
|
||||||
prevouts: &Prevouts<'_, impl core::borrow::Borrow<TxOut>>,
|
|
||||||
schnorr_sighashty: Option<SchnorrSighashType>,
|
|
||||||
_ecdsa_sighashty: Option<EcdsaSighashType>,
|
|
||||||
sighash_cache: &mut SighashCache<T>,
|
|
||||||
auth_data: &mut SatisfactionMaterial,
|
|
||||||
secp: &Secp256k1<impl Signing + Verification>,
|
|
||||||
) -> Result<bool, SigningError> {
|
|
||||||
match self {
|
|
||||||
RequiredSignatures::Legacy { .. } | RequiredSignatures::Segwitv0 { .. } => todo!(),
|
|
||||||
RequiredSignatures::TapKey {
|
|
||||||
plan_key,
|
|
||||||
merkle_root,
|
|
||||||
} => {
|
|
||||||
let schnorr_sighashty = schnorr_sighashty.unwrap_or(SchnorrSighashType::Default);
|
|
||||||
let sighash = sighash_cache.taproot_key_spend_signature_hash(
|
|
||||||
input_index,
|
|
||||||
prevouts,
|
|
||||||
schnorr_sighashty,
|
|
||||||
)?;
|
|
||||||
let secret_key = match keymap.get(&plan_key.asset_key) {
|
|
||||||
Some(secret_key) => secret_key,
|
|
||||||
None => return Ok(false),
|
|
||||||
};
|
|
||||||
let secret_key = match secret_key {
|
|
||||||
DescriptorSecretKey::Single(single) => single.key.inner,
|
|
||||||
DescriptorSecretKey::XPrv(xprv) => {
|
|
||||||
xprv.xkey
|
|
||||||
.derive_priv(&secp, &plan_key.derivation_hint)?
|
|
||||||
.private_key
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
let pubkey = PublicKey::from_secret_key(&secp, &secret_key);
|
|
||||||
let x_only_pubkey = XOnlyPublicKey::from(pubkey);
|
|
||||||
|
|
||||||
let tweak =
|
|
||||||
taproot::TapTweakHash::from_key_and_tweak(x_only_pubkey, merkle_root.clone());
|
|
||||||
let keypair = KeyPair::from_secret_key(&secp, &secret_key.clone())
|
|
||||||
.add_xonly_tweak(&secp, &tweak.to_scalar())
|
|
||||||
.unwrap();
|
|
||||||
|
|
||||||
let msg = Message::from_slice(sighash.as_ref()).expect("Sighashes are 32 bytes");
|
|
||||||
let sig = secp.sign_schnorr_no_aux_rand(&msg, &keypair);
|
|
||||||
|
|
||||||
let bitcoin_sig = SchnorrSig {
|
|
||||||
sig,
|
|
||||||
hash_ty: schnorr_sighashty,
|
|
||||||
};
|
|
||||||
|
|
||||||
auth_data
|
|
||||||
.schnorr_sigs
|
|
||||||
.insert(plan_key.descriptor_key.clone(), bitcoin_sig);
|
|
||||||
Ok(true)
|
|
||||||
}
|
|
||||||
RequiredSignatures::TapScript {
|
|
||||||
leaf_hash,
|
|
||||||
plan_keys,
|
|
||||||
} => {
|
|
||||||
let sighash_type = schnorr_sighashty.unwrap_or(SchnorrSighashType::Default);
|
|
||||||
let sighash = sighash_cache.taproot_script_spend_signature_hash(
|
|
||||||
input_index,
|
|
||||||
prevouts,
|
|
||||||
*leaf_hash,
|
|
||||||
sighash_type,
|
|
||||||
)?;
|
|
||||||
|
|
||||||
let mut modified = false;
|
|
||||||
|
|
||||||
for plan_key in plan_keys {
|
|
||||||
if let Some(secret_key) = keymap.get(&plan_key.asset_key) {
|
|
||||||
let secret_key = match secret_key {
|
|
||||||
DescriptorSecretKey::Single(single) => single.key.inner,
|
|
||||||
DescriptorSecretKey::XPrv(xprv) => {
|
|
||||||
xprv.xkey
|
|
||||||
.derive_priv(&secp, &plan_key.derivation_hint)?
|
|
||||||
.private_key
|
|
||||||
}
|
|
||||||
};
|
|
||||||
let keypair = KeyPair::from_secret_key(&secp, &secret_key.clone());
|
|
||||||
let msg =
|
|
||||||
Message::from_slice(sighash.as_ref()).expect("Sighashes are 32 bytes");
|
|
||||||
let sig = secp.sign_schnorr_no_aux_rand(&msg, &keypair);
|
|
||||||
let bitcoin_sig = SchnorrSig {
|
|
||||||
sig,
|
|
||||||
hash_ty: sighash_type,
|
|
||||||
};
|
|
||||||
|
|
||||||
auth_data
|
|
||||||
.schnorr_sigs
|
|
||||||
.insert(plan_key.descriptor_key.clone(), bitcoin_sig);
|
|
||||||
modified = true;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Ok(modified)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,76 +0,0 @@
|
|||||||
use bdk_chain::{bitcoin, miniscript};
|
|
||||||
use bitcoin::{
|
|
||||||
hashes::{hash160, ripemd160, sha256},
|
|
||||||
util::bip32::DerivationPath,
|
|
||||||
};
|
|
||||||
|
|
||||||
use super::*;
|
|
||||||
use crate::{hash256, varint_len, DefiniteDescriptorKey};
|
|
||||||
|
|
||||||
#[derive(Clone, Debug)]
|
|
||||||
pub(crate) enum TemplateItem<Ak> {
|
|
||||||
Sign(PlanKey<Ak>),
|
|
||||||
Pk { key: DefiniteDescriptorKey },
|
|
||||||
One,
|
|
||||||
Zero,
|
|
||||||
Sha256(sha256::Hash),
|
|
||||||
Hash256(hash256::Hash),
|
|
||||||
Ripemd160(ripemd160::Hash),
|
|
||||||
Hash160(hash160::Hash),
|
|
||||||
}
|
|
||||||
|
|
||||||
/// A plan key contains the asset key originally provided along with key in the descriptor it
|
|
||||||
/// purports to be able to derive for along with a "hint" on how to derive it.
|
|
||||||
#[derive(Clone, Debug)]
|
|
||||||
pub struct PlanKey<Ak> {
|
|
||||||
/// The key the planner will sign with
|
|
||||||
pub asset_key: Ak,
|
|
||||||
/// A hint from how to get from the asset key to the concrete key we need to sign with.
|
|
||||||
pub derivation_hint: DerivationPath,
|
|
||||||
/// The key that was in the descriptor that we are satisfying with the signature from the asset
|
|
||||||
/// key.
|
|
||||||
pub descriptor_key: DefiniteDescriptorKey,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<Ak> TemplateItem<Ak> {
|
|
||||||
pub fn expected_size(&self) -> usize {
|
|
||||||
match self {
|
|
||||||
TemplateItem::Sign { .. } => 64, /*size of sig TODO: take into consideration sighash falg*/
|
|
||||||
TemplateItem::Pk { .. } => 32,
|
|
||||||
TemplateItem::One => varint_len(1),
|
|
||||||
TemplateItem::Zero => 0, /* zero means an empty witness element */
|
|
||||||
// I'm not sure if it should be 32 here (it's a 20 byte hash) but that's what other
|
|
||||||
// parts of the code were doing.
|
|
||||||
TemplateItem::Hash160(_) | TemplateItem::Ripemd160(_) => 32,
|
|
||||||
TemplateItem::Sha256(_) | TemplateItem::Hash256(_) => 32,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// this can only be called if we are sure that auth_data has what we need
|
|
||||||
pub(super) fn to_witness_stack(&self, auth_data: &SatisfactionMaterial) -> Vec<Vec<u8>> {
|
|
||||||
match self {
|
|
||||||
TemplateItem::Sign(plan_key) => {
|
|
||||||
vec![auth_data
|
|
||||||
.schnorr_sigs
|
|
||||||
.get(&plan_key.descriptor_key)
|
|
||||||
.unwrap()
|
|
||||||
.to_vec()]
|
|
||||||
}
|
|
||||||
TemplateItem::One => vec![vec![1]],
|
|
||||||
TemplateItem::Zero => vec![vec![]],
|
|
||||||
TemplateItem::Sha256(image) => {
|
|
||||||
vec![auth_data.sha256_preimages.get(image).unwrap().to_vec()]
|
|
||||||
}
|
|
||||||
TemplateItem::Hash160(image) => {
|
|
||||||
vec![auth_data.hash160_preimages.get(image).unwrap().to_vec()]
|
|
||||||
}
|
|
||||||
TemplateItem::Ripemd160(image) => {
|
|
||||||
vec![auth_data.ripemd160_preimages.get(image).unwrap().to_vec()]
|
|
||||||
}
|
|
||||||
TemplateItem::Hash256(image) => {
|
|
||||||
vec![auth_data.hash256_preimages.get(image).unwrap().to_vec()]
|
|
||||||
}
|
|
||||||
TemplateItem::Pk { key } => vec![key.to_public_key().to_bytes()],
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Loading…
x
Reference in New Issue
Block a user