Struct pchain_types::blockchain::Transaction

pub struct Transaction {
    pub signer: PublicAddress,
    pub nonce: u64,
    pub commands: Vec<Command>,
    pub gas_limit: u64,
    pub max_base_fee_per_gas: u64,
    pub priority_fee_per_gas: u64,
    pub signature: SignatureBytes,
    pub hash: Sha256Hash,
}

Digitally signed instructions that tell the ParallelChain state machine to execute a sequence of commands.

Creating a Transaction

There are two ways of creating an instance of transaction:

1. Using the constructor function: this takes in the user-provided fields of a transaction and computes its signature and hash automatically.
2. Using a struct expression (i.e., Transaction { signer: ..., }): this does not check the signature and hash fields.

Fields

signer: PublicAddress

The public address of the external account which signed this transaction

nonce: u64

The number of transactions signed by the signer that have been included on the blockchain before this transaction. This ensures that all of the signer’s transactions are included in the blockchain in an expected order, and prevents the same transaction from being included in multiple blocks.

commands: Vec<Command>

A list of execution commands that triggers a sequence of state transitions

gas_limit: u64

The maximum number of gas units (ref.) that should be used in executing this transaction

max_base_fee_per_gas: u64

The maximum number of grays that the signer is willing to burn for a gas unit used in this transaction

priority_fee_per_gas: u64

the number of grays that the signer is willing to pay the block proposer for including this transaction in a block

signature: SignatureBytes

the signature formed by signing over content of this transaction by using the signer’s private key

hash: Sha256Hash

The cryptographic hash of signature

Implementations

impl Transaction

pub fn new( signer: &Keypair, nonce: u64, commands: Vec<Command>, gas_limit: u64, max_base_fee_per_gas: u64, priority_fee_per_gas: u64 ) -> Transaction

pub fn is_cryptographically_correct( &self ) -> Result<(), CryptographicallyIncorrectTransactionError>

Check whether the Transaction’s:

1. Signer is a valid Ed25519 public key.
2. Signature is a valid Ed25519 signature.
3. Signature is produced by the signer over the intermediate transaction.
4. Hash is the SHA256 hash over the signature.

Trait Implementations

impl BorshDeserialize for Transactionwhere PublicAddress: BorshDeserialize, u64: BorshDeserialize, Vec<Command>: BorshDeserialize, SignatureBytes: BorshDeserialize, Sha256Hash: BorshDeserialize,

fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self, Error>

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

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>where R: Read,

impl BorshSerialize for Transactionwhere PublicAddress: BorshSerialize, u64: BorshSerialize, Vec<Command>: BorshSerialize, SignatureBytes: BorshSerialize, Sha256Hash: BorshSerialize,

fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), Error>

fn try_to_vec(&self) -> Result<Vec<u8, Global>, Error>

Serialize this instance into a vector of bytes.

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 Deserializable for Transaction

fn deserialize(args: &[u8]) -> Result<Self, Error>

impl PartialEq<Transaction> 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 Serializable for Transaction

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

impl Eq for Transaction

impl StructuralEq for Transaction

impl StructuralPartialEq for Transaction