Struct thor_devkit::transactions::Transaction

pub struct Transaction {
    pub chain_tag: u8,
    pub block_ref: u64,
    pub expiration: u32,
    pub clauses: Vec<Clause>,
    pub gas_price_coef: u8,
    pub gas: u64,
    pub depends_on: Option<U256>,
    pub nonce: u64,
    pub reserved: Option<Reserved>,
    pub signature: Option<Bytes>,
}

Represents a single VeChain transaction.

Fields

chain_tag: u8

Chain tag

block_ref: u64

Previous block reference

First 4 bytes (BE) are block height, the rest is part of referred block ID.

expiration: u32

Expiration (in blocks)

clauses: Vec<Clause>

Vector of clauses

gas_price_coef: u8

Coefficient to calculate the gas price.

gas: u64

Maximal amount of gas to spend for transaction.

depends_on: Option<U256>

Hash of transaction on which current transaction depends.

May be left unspecified if this functionality is not necessary.

nonce: u64

Transaction nonce

reserved: Option<Reserved>

Reserved fields.

signature: Option<Bytes>

Signature. 65 bytes for regular transactions, 130 - for VIP-191.

Ignored when making a signing hash.

For VIP-191 transactions, this would be a simple concatenation of two signatures.

Implementations

impl Transaction

pub const TRANSACTION_GAS: u64 = 5_000u64

Gas cost for whole transaction execution.

pub fn get_signing_hash(&self) -> [u8; 32]

Get a signing hash for this transaction.

pub fn get_delegate_signing_hash(&self, delegate_for: &Address) -> [u8; 32]

Get a signing hash for this transaction with fee delegation.

VIP-191 <https://github.com/vechain/VIPs/blob/master/vips/VIP-191.md>

pub fn sign(self, private_key: &PrivateKey) -> Self

Create a copy of transaction with a signature emplaced.

You can call .encode() on the result to get bytes ready to be sent over wire.

pub fn with_signature(self, signature: Bytes) -> Result<Self, Error>

Set a signature for this transaction.

pub fn sign_hash(hash: [u8; 32], private_key: &PrivateKey) -> [u8; 65]

Sign a hash obtained from Transaction::get_signing_hash.

pub fn intrinsic_gas(&self) -> u64

Calculate the intrinsic gas amount required for this transaction.

This amount is always less than actual amount of gas necessary. More info <https://docs.vechain.org/core-concepts/transactions/transaction-calculation>

pub fn origin(&self) -> Result<Option<PublicKey>, Error>

Recover origin public key using the signature.

Returns Ok(None) if signature is unset.

pub fn delegator(&self) -> Result<Option<PublicKey>, Error>

Recover delegator public key using the signature.

Returns Ok(None) if signature is unset or transaction is not delegated.

pub fn is_delegated(&self) -> bool

Check if transaction is VIP-191 delegated.

pub fn id(&self) -> Result<Option<[u8; 32]>, Error>

Calculate transaction ID using the signature.

Returns Ok(None) if signature is unset.

pub fn has_valid_signature(&self) -> bool

Check wheter the signature is valid.

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

Create a binary representation.

Returns Err(secp256k1::Error::IncorrectSignature) if signature is not set.

Trait Implementations

impl Clone for Transaction

fn clone(&self) -> Transaction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Transaction

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

Formats the value using the given formatter.

impl Decodable for Transaction

fn decode(buf: &mut &[u8]) -> Result<Self, RLPError>

impl<'de> Deserialize<'de> for Transaction

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encodable for Transaction

fn encode(&self, out: &mut dyn BufMut)

fn length(&self) -> usize

impl PartialEq for Transaction

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Transaction

impl StructuralEq for Transaction

impl StructuralPartialEq for Transaction