Struct tuxedo_core::verifier::P2PKH

pub struct P2PKH {
    pub owner_pubkey_hash: H256,
}

Pay To Public Key Hash (P2PKH)

Require a signature from the private key corresponding to the public key whose hash is given. This is the most common way to represent private ownership in UTXO networks like Bitcoin. It is more complex than providing the public key directly but does not reveal the public key until spend time.

Uses the Sr25519 signature scheme and BlakeTwo256 hashing algorithm via Substrate’s host functions.

Fields

owner_pubkey_hash: H256

Trait Implementations

impl Clone for P2PKH

fn clone(&self) -> P2PKH

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for P2PKH

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

Formats the value using the given formatter.

impl Decode for P2PKH

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self> ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<'de> Deserialize<'de> for P2PKH

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encode for P2PKH

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn>( &self, f: __CodecUsingEncodedCallback ) -> __CodecOutputReturn

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl PartialEq for P2PKH

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for P2PKH

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TypeInfo for P2PKH

type Identity = P2PKH

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl Verifier for P2PKH

type Redeemer = (CryptoBytes<sp_core::::sr25519::Public::{constant#0}, Sr25519PublicTag>, CryptoBytes<sp_core::::sr25519::Signature::{constant#0}, (SignatureTag, Sr25519Tag)>)

The type that will be supplied to satisfy the verifier and redeem the UTXO.

fn verify( &self, simplified_tx: &[u8], _: u32, (pubkey, signature): &Self::Redeemer ) -> bool

Main function in the trait. Does the checks to make sure an output can be spent.

fn new_unspendable() -> Option<Self>

A way to create a new instance of the verifier whose semantics cannot be spent. This may be a signature check with a pubkey of 0 or a hashlock with a hash o 0 or a bitcoin script that directly returns false, etc.

impl EncodeLike for P2PKH

impl Eq for P2PKH

impl StructuralPartialEq for P2PKH