Struct darkfi::tx::Transaction

pub struct Transaction {
    pub calls: Vec<DarkLeaf<ContractCall>>,
    pub proofs: Vec<Vec<Proof>>,
    pub signatures: Vec<Vec<Signature>>,
}

A Transaction contains an arbitrary number of ContractCall objects, along with corresponding ZK proofs and Schnorr signatures.

DarkLeaf is used to map relations between contract calls in the transaction.

Fields

calls: Vec<DarkLeaf<ContractCall>>

Calls executed in this transaction

proofs: Vec<Vec<Proof>>

Attached ZK proofs

signatures: Vec<Vec<Signature>>

Attached Schnorr signatures

Implementations

impl Transaction

pub async fn verify_zkps( &self, verifying_keys: &HashMap<[u8; 32], HashMap<String, VerifyingKey>>, zkp_table: Vec<Vec<(String, Vec<Base>)>>, ) -> Result<()>

Verify ZK proofs for the entire transaction.

pub fn verify_sigs(&self, pub_table: Vec<Vec<PublicKey>>) -> Result<()>

Verify Schnorr signatures for the entire transaction.

pub fn create_sigs(&self, secret_keys: &[SecretKey]) -> Result<Vec<Signature>>

Create Schnorr signatures for the entire transaction.

pub fn hash(&self) -> TransactionHash

Get the transaction hash

pub fn is_pow_reward(&self) -> bool

Returns true if transaction is a PoW reward one.

pub fn is_single_call(&self) -> bool

Returns true if the transaction consists of a single call with non-empty data.

Trait Implementations

impl AsyncDecodable for Transaction

where Vec<DarkLeaf<ContractCall>>: AsyncDecodable, Vec<Vec<Proof>>: AsyncDecodable, Vec<Vec<Signature>>: AsyncDecodable,

fn decode_async<'life0, 'async_trait, D>( d: &'life0 mut D, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where D: 'async_trait + AsyncRead + Unpin + Send, Self: 'async_trait, 'life0: 'async_trait,

impl AsyncEncodable for Transaction

where Vec<DarkLeaf<ContractCall>>: AsyncEncodable, Vec<Vec<Proof>>: AsyncEncodable, Vec<Vec<Signature>>: AsyncEncodable,

fn encode_async<'life0, 'life1, 'async_trait, S>( &'life0 self, s: &'life1 mut S, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where S: 'async_trait + AsyncWrite + Unpin + Send, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Asynchronously encode an object with a well-defined format. Should only ever error if the underlying AsyncWrite errors. Returns the number of bytes written on success.

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

where Vec<DarkLeaf<ContractCall>>: Decodable, Vec<Vec<Proof>>: Decodable, Vec<Vec<Signature>>: Decodable,

fn decode<D: Read>(d: &mut D) -> Result<Self, Error>

impl Default for Transaction

fn default() -> Transaction

Returns the “default value” for a type.

impl Encodable for Transaction

where Vec<DarkLeaf<ContractCall>>: Encodable, Vec<Vec<Proof>>: Encodable, Vec<Vec<Signature>>: Encodable,

fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error>

Encode an object with a well-defined format. Should only ever error if the underlying Write errors. Returns the number of bytes written on success.

impl Message for Transaction

const NAME: &'static str = "tx"

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

impl StructuralPartialEq for Transaction