Struct Anchor

pub struct Anchor {
    pub mmb_proof: BundleProof,
    pub mpc_protocol: ProtocolId,
    pub mpc_proof: MerkleProof,
    pub dbc_proof: Option<TapretProof>,
    pub fallback_proof: ReservedBytes<1>,
}

Anchor is a client-side witness for the bitcoin txout seals.

Anchor is a set of data required for the client-side validation of a bitcoin txout single-use seal, which can’t be recovered from the transaction and other public information itself.

Fields

mmb_proof: BundleProof

The proof that each witness transaction input is used only in a single bundle.

mpc_protocol: ProtocolId

The protocol under which the client-side witness is valid.

mpc_proof: MerkleProof

The inclusion proof (using multiprotocol commitments) of a commitment under the [mpc_protocol] into the published witness.

dbc_proof: Option<TapretProof>

The deterministic bitcoin commitment proof that the witness commitment is valid.

fallback_proof: ReservedBytes<1>

Reserved for the future proofs regarding fallback seals.

Implementations

impl Anchor

pub fn is_fallback(&self) -> bool

Detect whether an anchor corresponds to a fallback proof or not.

Nota bene

In the current version fallback proofs are not implemented, and this method always returns false.

pub fn verify_fallback(&self) -> Result<(), AnchorError>

Verify the fallback proof.

Nota bene

In the current version fallback proofs are not implemented, and this method always returns Ok(()) (since if there is no fallback proof defined, it is a case of a valid situation).

Trait Implementations

impl ClientSideWitness for Anchor

type Proof = Proof

Proof which is passed from the client-side witness to the public-side witness during single-use seal validation.

type Seal = TxoSeal

Client-side witness is specific to just one type of single-use seals, provided as an associated type.

type Error = AnchorError

Error type returned by the Self::convolve_commit operation.

fn convolve_commit(&self, mmb_message: Message) -> Result<Proof, Self::Error>

Procedure that convolves the message with the client-side data kept in the client-side part of the seal closing witness. This produces Self::Proof, which is lately verified by SealWitness::verify_seal_closing and SealWitness::verify_seals_closing against the published part of the witness.

fn merge(&mut self, other: Self) -> Result<(), impl Error>

where Self: Sized,

Merge two compatible client-side witnesses together, or error in case of their incompatibility.

impl Clone for Anchor

fn clone(&self) -> Anchor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Anchor

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Anchor

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Anchor

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Anchor

fn cmp(&self, other: &Anchor) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Anchor

fn eq(&self, other: &Anchor) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Anchor

fn partial_cmp(&self, other: &Anchor) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Anchor

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StrictDecode for Anchor

fn strict_decode(reader: &mut impl TypedRead) -> Result<Self, DecodeError>

fn strict_read(reader: impl ReadRaw) -> Result<Self, DecodeError>

impl StrictDumb for Anchor

fn strict_dumb() -> Self

impl StrictEncode for Anchor

fn strict_encode<W: TypedWrite>(&self, writer: W) -> Result<W>

fn strict_write(&self, writer: impl WriteRaw) -> Result<(), Error>

impl StrictStruct for Anchor

const ALL_FIELDS: &'static [&'static str]

fn strict_check_fields()

fn strict_type_info() -> TypeInfo<Self>

impl StrictType for Anchor

const STRICT_LIB_NAME: &'static str = dbc::LIB_NAME_BPCORE

fn strict_name() -> Option<TypeName>

impl Eq for Anchor

impl StrictProduct for Anchor

impl StructuralPartialEq for Anchor