Struct StacksTransaction

pub struct StacksTransaction {
    pub version: TransactionVersion,
    pub chain_id: u32,
    pub auth: TransactionAuth,
    pub anchor_mode: TransactionAnchorMode,
    pub post_condition_mode: TransactionPostConditionMode,
    pub post_conditions: Vec<TransactionPostCondition>,
    pub payload: TransactionPayload,
}

Fields

version: TransactionVersion

chain_id: u32

auth: TransactionAuth

anchor_mode: TransactionAnchorMode

post_condition_mode: TransactionPostConditionMode

post_conditions: Vec<TransactionPostCondition>

payload: TransactionPayload

Implementations

impl StacksTransaction

pub fn new( version: TransactionVersion, auth: TransactionAuth, payload: TransactionPayload, ) -> StacksTransaction

Create a new, unsigned transaction and an empty STX fee with no post-conditions.

pub fn get_tx_fee(&self) -> u64

Get fee rate

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

Set fee rate

pub fn get_origin_nonce(&self) -> u64

Get origin nonce

pub fn get_sponsor_nonce(&self) -> Option<u64>

get sponsor nonce

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

set origin nonce

pub fn set_sponsor_nonce(&mut self, n: u64) -> Result<(), CodecError>

set sponsor nonce

pub fn set_anchor_mode(&mut self, anchor_mode: TransactionAnchorMode)

Set anchor mode

pub fn set_post_condition_mode( &mut self, postcond_mode: TransactionPostConditionMode, )

Set post-condition mode

pub fn add_post_condition(&mut self, post_condition: TransactionPostCondition)

Add a post-condition

pub fn txid(&self) -> Txid

a txid of a stacks transaction is its sha512/256 hash

pub fn borrow_auth(&mut self) -> &mut TransactionAuth

Get a mutable reference to the internal auth structure

pub fn auth(&self) -> &TransactionAuth

Get an immutable reference to the internal auth structure

pub fn sign_next_origin( &mut self, cur_sighash: &Txid, privk: &Secp256k1PrivateKey, ) -> Result<Txid, CodecError>

Append the next signature from the origin account authorization. Return the next sighash.

pub fn append_next_origin( &mut self, pubk: &Secp256k1PublicKey, ) -> Result<(), CodecError>

Append the next public key to the origin account authorization.

pub fn sign_next_sponsor( &mut self, cur_sighash: &Txid, privk: &Secp256k1PrivateKey, ) -> Result<Txid, CodecError>

Append the next signature from the sponsoring account. Return the next sighash

pub fn append_next_sponsor( &mut self, pubk: &Secp256k1PublicKey, ) -> Result<(), CodecError>

Append the next public key to the sponsor account authorization.

pub fn verify(&self) -> Result<(), CodecError>

Verify this transaction’s signatures

pub fn verify_origin(&self) -> Result<Txid, CodecError>

Verify the transaction’s origin signatures only. Used by sponsors to get the next sig-hash to sign.

pub fn origin_address(&self) -> StacksAddress

Get the origin account’s address

pub fn sponsor_address(&self) -> Option<StacksAddress>

Get the sponsor account’s address, if this transaction is sponsored

pub fn get_origin(&self) -> TransactionSpendingCondition

Get a copy of the origin spending condition

pub fn get_payer(&self) -> TransactionSpendingCondition

Get a copy of the sending condition that will pay the tx fee

pub fn is_mainnet(&self) -> bool

Is this a mainnet transaction? false means ‘testnet’

pub fn tx_len(&self) -> u64

pub fn consensus_deserialize_with_len<R: Read>( fd: &mut R, ) -> Result<(StacksTransaction, u64), CodecError>

Trait Implementations

impl Clone for StacksTransaction

fn clone(&self) -> StacksTransaction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for StacksTransaction

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StacksTransaction

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for StacksTransaction

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

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 StacksTransaction

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<StacksTransaction, 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 StacksTransaction