Enum clarity_repl::clarity::codec::transaction::TransactionSpendingCondition

pub enum TransactionSpendingCondition {
    Singlesig(SinglesigSpendingCondition),
    Multisig(MultisigSpendingCondition),
}

Variants

Singlesig(SinglesigSpendingCondition)

Multisig(MultisigSpendingCondition)

Implementations

impl TransactionSpendingCondition

pub fn new_singlesig_p2pkh(
    pubkey: Secp256k1PublicKey
) -> Option<TransactionSpendingCondition>

pub fn new_singlesig_p2wpkh(
    pubkey: Secp256k1PublicKey
) -> Option<TransactionSpendingCondition>

pub fn new_multisig_p2sh(
    num_sigs: u16,
    pubkeys: Vec<Secp256k1PublicKey>
) -> Option<TransactionSpendingCondition>

pub fn new_multisig_p2wsh(
    num_sigs: u16,
    pubkeys: Vec<Secp256k1PublicKey>
) -> Option<TransactionSpendingCondition>

pub fn new_initial_sighash() -> TransactionSpendingCondition

When committing to the fact that a transaction is sponsored, the origin doesn’t know anything else. Instead, it commits to this sentinel value as its sponsor. It is intractable to calculate a private key that could generate this.

pub fn num_signatures(&self) -> u16

pub fn signatures_required(&self) -> u16

pub fn nonce(&self) -> u64

pub fn tx_fee(&self) -> u64

pub fn set_nonce(&mut self, n: u64)

pub fn set_tx_fee(&mut self, tx_fee: u64)

pub fn get_tx_fee(&self) -> u64

pub fn address_mainnet(&self) -> StacksAddress

Get the mainnet account address of the spending condition

pub fn address_testnet(&self) -> StacksAddress

Get the mainnet account address of the spending condition

pub fn clear(&mut self)

Clear fee rate, nonces, signatures, and public keys

pub fn make_sighash_presign(
    cur_sighash: &Txid,
    cond_code: &TransactionAuthFlags,
    tx_fee: u64,
    nonce: u64
) -> Txid

pub fn make_sighash_postsign(
    cur_sighash: &Txid,
    pubkey: &Secp256k1PublicKey,
    sig: &RecoverableSignature
) -> Txid

pub fn next_signature(
    cur_sighash: &Txid,
    cond_code: &TransactionAuthFlags,
    tx_fee: u64,
    nonce: u64,
    privk: &Secp256k1PrivateKey
) -> Result<(RecoverableSignature, Txid), CodecError>

Linear-complexity signing algorithm – we sign a rolling hash over all data committed to by the previous signer (instead of naively re-serializing the transaction each time), as well as over new data provided by this key (excluding its own public key or signature, which are authenticated by the spending condition’s key hash). Calculates and returns the next signature and sighash, which the subsequent private key must sign.

pub fn next_verification(
    cur_sighash: &Txid,
    cond_code: &TransactionAuthFlags,
    tx_fee: u64,
    nonce: u64,
    key_encoding: &TransactionPublicKeyEncoding,
    sig: &RecoverableSignature
) -> Result<(Secp256k1PublicKey, Txid), CodecError>

Linear-complexity verifying algorithm – we verify a rolling hash over all data committed to by order of signers (instead of re-serializing the tranasction each time). Calculates the next sighash and public key, which the next verifier must verify. Used by StacksTransaction::verify*

pub fn verify(
    &self,
    initial_sighash: &Txid,
    cond_code: &TransactionAuthFlags
) -> Result<Txid, CodecError>

Verify all signatures

Trait Implementations

impl Clone for TransactionSpendingCondition

fn clone(&self) -> TransactionSpendingCondition

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TransactionSpendingCondition

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TransactionSpendingCondition

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq<TransactionSpendingCondition> for TransactionSpendingCondition

fn eq(&self, other: &TransactionSpendingCondition) -> 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 TransactionSpendingCondition

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

Serialize this value into the given Serde serializer.

impl StacksMessageCodec for TransactionSpendingCondition

fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError>

serialize implementors should never error unless there is an underlying failure in writing to the fd

fn consensus_deserialize<R: Read>(
    fd: &mut R
) -> Result<TransactionSpendingCondition, CodecError>

fn serialize_to_vec(&self) -> Vec<u8>where
    Self: Sized,

Convenience for serialization to a vec. this function unwraps any underlying serialization error

impl StructuralPartialEq for TransactionSpendingCondition