Struct bdk_bitcoind_rpc::BlockEvent

source Â·

pub struct BlockEvent<B> {
     pub block: B,
-    pub checkpoint: CheckPoint,
+    pub checkpoint: CheckPoint,
 }

Expand description

A newly emitted block from Emitter.

FieldsÂ§

Â§block: B

Either a full [Block] or [Header] of the new block.

Â§checkpoint: CheckPoint

The checkpoint of the new block.

A CheckPoint is a node of a linked list of BlockIds. This checkpoint is linked to -all BlockIds originally passed in Emitter::new as well as emitted blocks since then. +

Â§checkpoint: CheckPoint

The checkpoint of the new block.

A [CheckPoint] is a node of a linked list of [BlockId]s. This checkpoint is linked to +all [BlockId]s originally passed in Emitter::new as well as emitted blocks since then. These blocks are guaranteed to be of the same chain.

This is important as BDK structures require block-to-apply to be connected with another block in the original chain.

List of all items

Structs

Enums

Traits

Macros

Functions

Type Definitions

Function bdk::descriptor::checksum::calc_checksum

Function bdk::descriptor::checksum::calc_checksum_bytes

Module bdk::descriptor::checksum

Enum bdk::descriptor::Descriptor

VariantsÂ§

Bare(Bare<Pk>)

Pkh(Pkh<Pk>)

Wpkh(Wpkh<Pk>)

Sh(Sh<Pk>)

Wsh(Wsh<Pk>)

Tr(Tr<Pk>)

ImplementationsÂ§

impl<Pk> Descriptor<Pk>where Pk: MiniscriptKey,

pub fn new_pk(pk: Pk) -> Descriptor<Pk>

pub fn new_pkh(pk: Pk) -> Result<Descriptor<Pk>, Error>

pub fn new_wpkh(pk: Pk) -> Result<Descriptor<Pk>, Error>

pub fn new_sh_wpkh(pk: Pk) -> Result<Descriptor<Pk>, Error>

pub fn new_sh(ms: Miniscript<Pk, Legacy>) -> Result<Descriptor<Pk>, Error>

pub fn new_wsh(ms: Miniscript<Pk, Segwitv0>) -> Result<Descriptor<Pk>, Error>

pub fn new_sh_wsh(ms: Miniscript<Pk, Segwitv0>) -> Result<Descriptor<Pk>, Error>

pub fn new_bare(ms: Miniscript<Pk, BareCtx>) -> Result<Descriptor<Pk>, Error>

pub fn new_sh_with_wpkh(wpkh: Wpkh<Pk>) -> Descriptor<Pk>

pub fn new_sh_with_wsh(wsh: Wsh<Pk>) -> Descriptor<Pk>

pub fn new_sh_sortedmulti( k: usize, pks: Vec<Pk, Global>) -> Result<Descriptor<Pk>, Error>

pub fn new_sh_wsh_sortedmulti( k: usize, pks: Vec<Pk, Global>) -> Result<Descriptor<Pk>, Error>

pub fn new_wsh_sortedmulti( k: usize, pks: Vec<Pk, Global>) -> Result<Descriptor<Pk>, Error>

pub fn new_tr( key: Pk, script: Option<TapTree<Pk>>) -> Result<Descriptor<Pk>, Error>

pub fn desc_type(&self) -> DescriptorType

pub fn sanity_check(&self) -> Result<(), Error>

pub fn max_weight_to_satisfy(&self) -> Result<usize, Error>

pub fn max_satisfaction_weight(&self) -> Result<usize, Error>

impl<Pk> Descriptor<Pk>where Pk: MiniscriptKey + ToPublicKey,

pub fn address(&self, network: Network) -> Result<Address<NetworkChecked>, Error>

pub fn script_pubkey(&self) -> ScriptBuf

pub fn unsigned_script_sig(&self) -> ScriptBuf

pub fn explicit_script(&self) -> Result<ScriptBuf, Error>

pub fn script_code(&self) -> Result<ScriptBuf, Error>

pub fn get_satisfaction<S>( &self, satisfier: S) -> Result<(Vec<Vec<u8, Global>, Global>, ScriptBuf), Error>where S: Satisfier<Pk>,

pub fn get_satisfaction_mall<S>( &self, satisfier: S) -> Result<(Vec<Vec<u8, Global>, Global>, ScriptBuf), Error>where S: Satisfier<Pk>,

pub fn satisfy<S>(&self, txin: &mut TxIn, satisfier: S) -> Result<(), Error>where S: Satisfier<Pk>,

impl Descriptor<DefiniteDescriptorKey>

pub fn plan<P>( self, provider: &P) -> Result<Plan, Descriptor<DefiniteDescriptorKey>>where P: AssetProvider<DefiniteDescriptorKey>,

pub fn plan_mall<P>( self, provider: &P) -> Result<Plan, Descriptor<DefiniteDescriptorKey>>where P: AssetProvider<DefiniteDescriptorKey>,

impl Descriptor<DescriptorPublicKey>

pub fn is_deriveable(&self) -> bool

pub fn has_wildcard(&self) -> bool

pub fn at_derivation_index( &self, index: u32) -> Result<Descriptor<DefiniteDescriptorKey>, ConversionError>

pub fn derive( &self, index: u32) -> Result<Descriptor<DefiniteDescriptorKey>, ConversionError>

pub fn derived_descriptor<C>( &self, secp: &Secp256k1<C>, index: u32) -> Result<Descriptor<PublicKey>, ConversionError>where C: Verification,

pub fn parse_descriptor<C>( secp: &Secp256k1<C>, s: &str) -> Result<(Descriptor<DescriptorPublicKey>, BTreeMap<DescriptorPublicKey, DescriptorSecretKey, Global>), Error>where C: Signing,

pub fn to_string_with_secret( &self, key_map: &BTreeMap<DescriptorPublicKey, DescriptorSecretKey, Global>) -> String

pub fn find_derivation_index_for_spk<C>( &self, secp: &Secp256k1<C>, script_pubkey: &Script, range: Range<u32>) -> Result<Option<(u32, Descriptor<PublicKey>)>, ConversionError>where C: Verification,

pub fn is_multipath(&self) -> bool

pub fn into_single_descriptors( self) -> Result<Vec<Descriptor<DescriptorPublicKey>, Global>, Error>

impl Descriptor<DefiniteDescriptorKey>

pub fn derived_descriptor<C>( &self, secp: &Secp256k1<C>) -> Result<Descriptor<PublicKey>, ConversionError>where C: Verification,

Trait ImplementationsÂ§

impl<Pk> Clone for Descriptor<Pk>where Pk: Clone + MiniscriptKey,

fn clone(&self) -> Descriptor<Pk>

fn clone_from(&mut self, source: &Self)

impl<Pk> Debug for Descriptor<Pk>where Pk: MiniscriptKey,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl DescriptorExt for Descriptor<DescriptorPublicKey>

fn dust_value(&self) -> u64

fn descriptor_id(&self) -> DescriptorId

fn deserialize<D>( deserializer: D) -> Result<Descriptor<Pk>, <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

impl<Pk> Display for Descriptor<Pk>where Pk: MiniscriptKey,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl ExtractPolicy for Descriptor<DescriptorPublicKey>

fn extract_policy( &self, signers: &SignersContainer, build_sat: BuildSatisfaction<'_>, secp: &Secp256k1<All>) -> Result<Option<Policy>, Error>

impl<Pk> ForEachKey<Pk> for Descriptor<Pk>where Pk: MiniscriptKey,

fn for_each_key<'a, F>(&'a self, pred: F) -> boolwhere F: FnMut(&'a Pk) -> bool,

fn for_any_key<'a, F>(&'a self, pred: F) -> boolwhere F: FnMut(&'a Pk) -> bool, Pk: 'a,

impl<Pk> Descriptor<Pk>where
Pk: MiniscriptKey,

pub fn new_sh_sortedmulti(
k: usize,
pks: Vec<Pk, Global>
) -> Result<Descriptor<Pk>, Error>

pub fn new_sh_wsh_sortedmulti(
k: usize,
pks: Vec<Pk, Global>
) -> Result<Descriptor<Pk>, Error>

pub fn new_wsh_sortedmulti(
k: usize,
pks: Vec<Pk, Global>
) -> Result<Descriptor<Pk>, Error>

pub fn new_tr(
key: Pk,
script: Option<TapTree<Pk>>
) -> Result<Descriptor<Pk>, Error>

impl<Pk> Descriptor<Pk>where
Pk: MiniscriptKey + ToPublicKey,

pub fn get_satisfaction<S>(
&self,
satisfier: S
) -> Result<(Vec<Vec<u8, Global>, Global>, ScriptBuf), Error>where
S: Satisfier<Pk>,

pub fn get_satisfaction_mall<S>(
&self,
satisfier: S
) -> Result<(Vec<Vec<u8, Global>, Global>, ScriptBuf), Error>where
S: Satisfier<Pk>,

pub fn satisfy<S>(&self, txin: &mut TxIn, satisfier: S) -> Result<(), Error>where
S: Satisfier<Pk>,

pub fn plan<P>(
self,
provider: &P
) -> Result<Plan, Descriptor<DefiniteDescriptorKey>>where
P: AssetProvider<DefiniteDescriptorKey>,

pub fn plan_mall<P>(
self,
provider: &P
) -> Result<Plan, Descriptor<DefiniteDescriptorKey>>where
P: AssetProvider<DefiniteDescriptorKey>,

pub fn at_derivation_index(
&self,
index: u32
) -> Result<Descriptor<DefiniteDescriptorKey>, ConversionError>

pub fn derive(
&self,
index: u32
) -> Result<Descriptor<DefiniteDescriptorKey>, ConversionError>

pub fn derived_descriptor<C>(
&self,
secp: &Secp256k1<C>,
index: u32
) -> Result<Descriptor<PublicKey>, ConversionError>where
C: Verification,

pub fn parse_descriptor<C>(
secp: &Secp256k1<C>,
s: &str
) -> Result<(Descriptor<DescriptorPublicKey>, BTreeMap<DescriptorPublicKey, DescriptorSecretKey, Global>), Error>where
C: Signing,

pub fn to_string_with_secret(
&self,
key_map: &BTreeMap<DescriptorPublicKey, DescriptorSecretKey, Global>
) -> String

pub fn find_derivation_index_for_spk<C>(
&self,
secp: &Secp256k1<C>,
script_pubkey: &Script,
range: Range<u32>
) -> Result<Option<(u32, Descriptor<PublicKey>)>, ConversionError>where
C: Verification,

pub fn into_single_descriptors(
self
) -> Result<Vec<Descriptor<DescriptorPublicKey>, Global>, Error>

pub fn derived_descriptor<C>(
&self,
secp: &Secp256k1<C>
) -> Result<Descriptor<PublicKey>, ConversionError>where
C: Verification,

impl<Pk> Clone for Descriptor<Pk>where
Pk: Clone + MiniscriptKey,

impl<Pk> Debug for Descriptor<Pk>where
Pk: MiniscriptKey,

fn deserialize<D>(
deserializer: D
) -> Result<Descriptor<Pk>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,

impl<Pk> Display for Descriptor<Pk>where
Pk: MiniscriptKey,

fn extract_policy(
&self,
signers: &SignersContainer,
build_sat: BuildSatisfaction<'_>,
secp: &Secp256k1<All>
) -> Result<Option<Policy>, Error>

impl<Pk> ForEachKey<Pk> for Descriptor<Pk>where
Pk: MiniscriptKey,

fn for_each_key<'a, F>(&'a self, pred: F) -> boolwhere
F: FnMut(&'a Pk) -> bool,

fn for_any_key<'a, F>(&'a self, pred: F) -> boolwhere
F: FnMut(&'a Pk) -> bool,
Pk: 'a,

impl<Pk> From<Bare<Pk>> for Descriptor<Pk>where
Pk: MiniscriptKey,

impl<Pk> From<Pkh<Pk>> for Descriptor<Pk>where
Pk: MiniscriptKey,

impl<Pk> From<Sh<Pk>> for Descriptor<Pk>where
Pk: MiniscriptKey,

impl<Pk> From<Tr<Pk>> for Descriptor<Pk>where
Pk: MiniscriptKey,

impl<Pk> From<Wpkh<Pk>> for Descriptor<Pk>where
Pk: MiniscriptKey,

impl<Pk> From<Wsh<Pk>> for Descriptor<Pk>where
Pk: MiniscriptKey,

impl<Pk> Hash for Descriptor<Pk>where
Pk: Hash + MiniscriptKey,

fn hash<H>(&self, state: &mut H)where
__H: Hasher,

fn hash_slice<H>(data: &[Self], state: &mut H)where
H: Hasher,
Self: Sized,

impl<Pk> Liftable<Pk> for Descriptor<Pk>where
Pk: MiniscriptKey,

impl<Pk> Ord for Descriptor<Pk>where
Pk: Ord + MiniscriptKey,

fn max(self, other: Self) -> Selfwhere
Self: Sized,

fn min(self, other: Self) -> Selfwhere
Self: Sized,

fn clamp(self, min: Self, max: Self) -> Selfwhere
Self: Sized + PartialOrd<Self>,

impl<Pk> PartialEq<Descriptor<Pk>> for Descriptor<Pk>where
Pk: PartialEq<Pk> + MiniscriptKey,

impl<Pk> PartialOrd<Descriptor<Pk>> for Descriptor<Pk>where
Pk: PartialOrd<Pk> + MiniscriptKey,

impl<'de, Pk> Serialize for Descriptor<Pk>where
Pk: MiniscriptKey,

fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

impl<P, Q> TranslatePk<P, Q> for Descriptor<P>where
P: MiniscriptKey,
Q: MiniscriptKey,

fn translate_pk<T, E>(
&self,
t: &mut T
) -> Result<<Descriptor<P> as TranslatePk<P, Q>>::Output, TranslateErr<E>>where
T: Translator<P, Q, E>,

impl<Pk> Eq for Descriptor<Pk>where
Pk: Eq + MiniscriptKey,

impl<Pk> StructuralEq for Descriptor<Pk>where
Pk: MiniscriptKey,