Struct Transaction 

pub struct Transaction(pub(crate) Transaction);

A Zcash transaction, wrapping zcash_primitives::transaction::Transaction.

Tuple Fields

0: Transaction

Implementations

impl Transaction

pub fn v1_strategy(ledger_state: LedgerState) -> BoxedStrategy<Self>

Generate a proptest strategy for V1 Transactions

pub fn v2_strategy(ledger_state: LedgerState) -> BoxedStrategy<Self>

Generate a proptest strategy for V2 Transactions

Note: the new Transaction type doesn’t support arbitrary Sprout JoinSplit data in proptest strategies, so this generates transparent-only V2 transactions.

pub fn v3_strategy(ledger_state: LedgerState) -> BoxedStrategy<Self>

Generate a proptest strategy for V3 Transactions

Note: the new Transaction type doesn’t support arbitrary Sprout JoinSplit data in proptest strategies, so this generates transparent-only V3 transactions.

pub fn v4_strategy(ledger_state: LedgerState) -> BoxedStrategy<Self>

Generate a proptest strategy for V4 Transactions

Note: the new Transaction type doesn’t support arbitrary Sapling/Sprout shielded data in proptest strategies, so this generates transparent-only V4 transactions.

pub fn v5_strategy(ledger_state: LedgerState) -> BoxedStrategy<Self>

Generate a proptest strategy for V5 Transactions

Note: the new Transaction type doesn’t support arbitrary Sapling/Orchard shielded data in proptest strategies, so this generates transparent-only V5 transactions.

pub fn v6_strategy(ledger_state: LedgerState) -> BoxedStrategy<Self>

Generate a proptest strategy for V6 Transactions

Note: like Self::v5_strategy, the new Transaction type doesn’t support arbitrary shielded data in proptest strategies, so this generates transparent-only V6 transactions.

pub fn vec_strategy( ledger_state: LedgerState, len: usize, ) -> BoxedStrategy<Vec<Arc<Self>>>

Proptest Strategy for creating a Vector of transactions where the first transaction is always the only coinbase transaction

pub fn for_each_value_mut<F>(&mut self, f: F)

where F: FnMut(&mut Amount<NonNegative>),

Apply f to the transparent output values in this transaction.

Note: Sprout/sapling/orchard value mutations are not supported with the new Transaction type (proptest strategies generate transparent-only txs).

pub fn for_each_value_balance_mut<F>(&mut self, _f: F)

where F: FnMut(&mut Amount<NegativeAllowed>),

Apply f to the sapling value balance and orchard value balance.

Note: Not implemented for the new Transaction type since proptest strategies generate transparent-only transactions. This is a no-op.

pub fn fix_overflow(&mut self)

Fixup transparent values and shielded value balances, so that transaction and chain value pools won’t overflow MAX_MONEY.

These fixes are applied to coinbase and non-coinbase transactions.

pub fn fix_chain_value_pools( &mut self, chain_value_pools: ValueBalance<NonNegative>, outputs: &HashMap<OutPoint, Output>, ) -> Result<(Amount<NonNegative>, ValueBalance<NonNegative>), ValueBalanceError>

Fixup transparent values and shielded value balances, so that this transaction passes the “non-negative chain value pool” checks. (These checks use the sum of unspent outputs for each transparent and shielded pool.)

These fixes are applied to coinbase and non-coinbase transactions.

chain_value_pools contains the chain value pool balances, as of the previous transaction in this block (or the last transaction in the previous block).

outputs must contain all the transparent::Outputs spent in this transaction.

Currently, these fixes almost always leave some remaining value in each transparent and shielded chain value pool.

Before fixing the chain value balances, this method calls fix_overflow to make sure that transaction and chain value pools don’t overflow MAX_MONEY.

After fixing the chain value balances, this method calls fix_remaining_value to fix the remaining value in the transaction value pool.

Returns the remaining transaction value, and the updated chain value balances.

Panics

If any spent transparent::Output is missing from transparent::OutPoints.

fn input_value_pool( &self, outputs: &HashMap<OutPoint, Output>, ) -> Result<Amount<NonNegative>, ValueBalanceError>

Returns the total input value of this transaction’s value pool.

This is the sum of transparent inputs, sprout input values, and if positive, the sapling, orchard, and ironwood value balances.

outputs must contain all the transparent::Outputs spent in this transaction.

pub fn fix_remaining_value( &mut self, outputs: &HashMap<OutPoint, Output>, ) -> Result<Amount<NonNegative>, ValueBalanceError>

Fixup non-coinbase transparent values and shielded value balances, so that this transaction passes the “non-negative remaining transaction value” check. (This check uses the sum of inputs minus outputs.)

Returns the remaining transaction value.

outputs must contain all the transparent::Outputs spent in this transaction.

Currently, these fixes almost always leave some remaining value in the transaction value pool.

Panics

If any spent transparent::Output is missing from transparent::OutPoints.

impl Transaction

pub(crate) fn inner(&self) -> &Transaction

Access the inner zcash_primitives::transaction::Transaction.

pub fn tx_version(&self) -> TxVersion

Returns the transaction version.

pub fn version(&self) -> u32

Returns the numeric version of this transaction.

pub fn is_overwintered(&self) -> bool

Returns true if this is an overwinter or later transaction.

pub fn network_upgrade(&self) -> Option<NetworkUpgrade>

Get the network upgrade for this transaction, if any (V5+).

pub fn sighash( &self, network_upgrade: NetworkUpgrade, hash_type: HashType, all_previous_outputs: Arc<Vec<Output>>, input_index_script_code: Option<(usize, Vec<u8>)>, ) -> Result<SigHash, Error>

Compute the sighash for this transaction.

Returns an error if network_upgrade doesn’t match the transaction’s consensus branch ID.

pub fn sighasher( &self, network_upgrade: NetworkUpgrade, all_previous_outputs: Arc<Vec<Output>>, ) -> Result<SigHasher, Error>

Returns a SigHasher for this transaction.

Returns an error if network_upgrade doesn’t match the transaction’s consensus branch ID.

pub fn lock_time(&self) -> Option<LockTime>

Get this transaction’s lock time.

pub fn raw_lock_time(&self) -> u32

Get the raw lock time value as a u32.

pub fn lock_time_is_time(&self) -> bool

Returns true if lock_time is a LockTime::Time and is not disabled by sequence numbers.

pub fn expiry_height(&self) -> Option<Height>

Get the expiry height for this transaction, if any (V3+).

Returns None if the transaction is Sprout, or if nExpiryHeight == 0 (which means “no expiry” per the Zcash protocol spec).

Returns the raw wire value, which can exceed block::Height::MAX: the ZIP-203 maximum of 499,999,999 is a verifier rule, not a limit of this accessor, so an out-of-range value must reach the verifier to be rejected.

pub fn version_group_id(&self) -> Option<u32>

Get the version group ID for this transaction, if any.

pub fn inputs(&self) -> Vec<Input>

Get the transparent inputs, converted to Zebra types.

pub fn outputs(&self) -> Vec<Output>

Get the transparent outputs, converted to Zebra types.

pub fn has_transparent_inputs(&self) -> bool

Returns true if this transaction has transparent inputs.

pub fn has_transparent_outputs(&self) -> bool

Returns true if this transaction has transparent outputs.

pub fn has_transparent_inputs_or_outputs(&self) -> bool

Returns true if this transaction has transparent inputs or outputs.

pub fn is_coinbase(&self) -> bool

Returns true if this is a coinbase transaction.

pub fn is_valid_non_coinbase(&self) -> bool

Returns true if this transaction has valid inputs for a non-coinbase transaction, that is, none of its transparent inputs has a null prevout.

Consensus

A transparent input in a non-coinbase transaction MUST NOT have a null prevout.

https://zips.z.cash/protocol/protocol.pdf#txnconsensus

Note that a transaction can return false from both Transaction::is_coinbase and this method, for example a transaction with a null-prevout input alongside other inputs. Such transactions are rejected by the verifier.

pub fn spent_outpoints(&self) -> impl Iterator<Item = OutPoint> + '_

Returns the outpoints spent by this transaction’s transparent inputs.

pub fn hash(&self) -> Hash

Compute the hash (txid) of this transaction.

pub fn auth_digest(&self) -> Option<AuthDigest>

Compute the authorizing data commitment for this transaction.

Returns None for pre-V5 transactions (which don’t have auth digests).

pub fn unmined_id(&self) -> UnminedTxId

Compute the unmined transaction ID for this transaction.

pub fn joinsplit_count(&self) -> usize

Returns the number of JoinSplit descriptions in this transaction.

pub fn has_sprout_joinsplit_data(&self) -> bool

Returns true if this transaction has Sprout JoinSplit data.

pub fn sprout_joinsplit_descriptions( &self, ) -> impl Iterator<Item = &JsDescription> + '_

Iterate over the Sprout JoinSplit descriptions (librustzcash type).

pub fn sprout_nullifiers(&self) -> impl Iterator<Item = Nullifier> + '_

Access the Sprout nullifiers in this transaction.

pub fn sprout_note_commitments( &self, ) -> impl Iterator<Item = NoteCommitment> + '_

Access the Sprout note commitments in this transaction.

pub fn output_values_to_sprout(&self) -> Vec<i64>

Returns vpub_old values (amounts entering the Sprout pool).

pub fn input_values_from_sprout(&self) -> Vec<i64>

Returns vpub_new values (amounts leaving the Sprout pool).

pub fn sprout_joinsplit_pub_key(&self) -> Option<VerificationKeyBytes>

Access the JoinSplit public validating key, if any.

pub fn has_sapling_shielded_data(&self) -> bool

Returns true if this transaction has Sapling shielded data.

pub fn sapling_nullifiers(&self) -> impl Iterator<Item = Nullifier> + '_

Access the Sapling nullifiers in this transaction.

pub fn sapling_spends( &self, ) -> impl Iterator<Item = &SpendDescription<Authorized>> + '_

Access the Sapling spend descriptions (librustzcash type).

The spend description type uses GrothProofBytes for proofs and redjubjub::Signature<SpendAuth> for auth sigs.

pub fn sapling_spends_count(&self) -> usize

Returns the number of Sapling spends.

pub fn sapling_outputs( &self, ) -> impl Iterator<Item = &OutputDescription<GrothProofBytes>> + '_

Access the Sapling output descriptions (librustzcash type).

pub fn sapling_note_commitments( &self, ) -> impl Iterator<Item = ExtractedNoteCommitment> + '_

Access the Sapling note commitments in this transaction.

pub fn sapling_anchors(&self) -> Vec<Root>

Iterate over deduplicated Sapling anchors as zebra tree roots.

pub fn sapling_value_balance(&self) -> ValueBalance<NegativeAllowed>

Get the Sapling value balance.

pub fn has_orchard_shielded_data(&self) -> bool

Returns true if this transaction has Orchard shielded data.

pub fn orchard_nullifiers(&self) -> impl Iterator<Item = Nullifier> + '_

Access the Orchard nullifiers in this transaction.

pub fn orchard_actions( &self, ) -> impl Iterator<Item = &Action<<Authorized as Authorization>::SpendAuth>> + '_

Access the Orchard actions (librustzcash type).

pub fn orchard_note_commitments( &self, ) -> impl Iterator<Item = ExtractedNoteCommitment> + '_

Access Orchard note commitments.

pub fn orchard_flags(&self) -> Option<Flags>

Access the Orchard flags, if any.

pub fn orchard_anchor(&self) -> Option<Root>

Access the Orchard anchor as a zebra tree root, if any.

pub fn orchard_value_balance(&self) -> ValueBalance<NegativeAllowed>

Get the Orchard value balance.

pub fn has_ironwood_shielded_data(&self) -> bool

Returns true if this transaction has an Ironwood bundle.

pub fn ironwood_nullifiers(&self) -> impl Iterator<Item = Nullifier> + '_

Access the Ironwood nullifiers in this transaction.

pub fn ironwood_actions( &self, ) -> impl Iterator<Item = &Action<<Authorized as Authorization>::SpendAuth>> + '_

Access the Ironwood actions (librustzcash type).

pub fn ironwood_note_commitments( &self, ) -> impl Iterator<Item = ExtractedNoteCommitment> + '_

Access Ironwood note commitments.

pub fn ironwood_flags(&self) -> Option<Flags>

Access the Ironwood flags, if any.

pub fn ironwood_anchor(&self) -> Option<Root>

Access the Ironwood anchor as a zebra tree root, if any.

pub fn has_enough_ironwood_flags(&self) -> bool

Returns true unless this transaction has an Ironwood bundle that enables neither spends nor outputs.

pub fn ironwood_value_balance(&self) -> ValueBalance<NegativeAllowed>

Get the Ironwood value balance.

Positive values are added to this transaction’s value pool, and removed from the Ironwood chain value pool. Negative values are removed from this transaction, and added to the Ironwood pool. This is zero for transactions without an Ironwood bundle.

https://zebra.zfnd.org/dev/rfcs/0012-value-pools.html#definitions

pub fn orchard_proof_size_is_canonical(&self) -> bool

Returns true if the Orchard bundle’s Halo2 proof has the canonical size for its action count, or if there is no Orchard bundle.

A proof that is present but not canonically sized can be padded with arbitrary trailing data without affecting its validity (GHSA-jfw5-j458-pfv6). Bundles are deserialized leniently, so this is checked by the verifier rather than during parsing.

pub fn ironwood_proof_size_is_canonical(&self) -> bool

Returns true if the Ironwood bundle’s Halo2 proof has the canonical size for its action count, or if there is no Ironwood bundle.

See Self::orchard_proof_size_is_canonical; Ironwood reuses the Orchard circuit, so it has the same expected proof size.

pub fn has_shielded_inputs(&self) -> bool

Returns true if this transaction has shielded inputs.

pub fn has_shielded_outputs(&self) -> bool

Returns true if this transaction has shielded outputs.

pub fn has_shielded_data(&self) -> bool

Does this transaction have shielded inputs or outputs?

pub fn has_transparent_or_shielded_inputs(&self) -> bool

Returns true if this transaction has transparent or shielded inputs.

pub fn has_transparent_or_shielded_outputs(&self) -> bool

Returns true if this transaction has transparent or shielded outputs.

pub fn has_enough_orchard_flags(&self) -> bool

Returns true if the Orchard flags are consistent.

pub fn transparent_value_balance_from_outputs( &self, outputs: &HashMap<OutPoint, Output>, ) -> Result<ValueBalance<NegativeAllowed>, ValueBalanceError>

Return the transparent value balance, the change in the transaction value pool due to transparent inputs and outputs.

pub fn sprout_value_balance( &self, ) -> Result<ValueBalance<NegativeAllowed>, ValueBalanceError>

Return the sprout value balance.

Errors when the aggregate JoinSplit value balance (or any prefix of it, matching the pre-refactor fold) leaves the valid monetary range. Aggregated here because zcash_primitives collapses that case to None, conflating it with “no Sprout bundle”. The net-sum bound matches zcashd from Canopy onward, where vpub_old is always zero; pre-Canopy heights are checkpointed.

pub fn value_balance( &self, utxos: &HashMap<OutPoint, Utxo>, ) -> Result<ValueBalance<NegativeAllowed>, ValueBalanceError>

Get the overall value balance for this transaction.

pub fn coinbase_spend_restriction( &self, network: &Network, spend_height: Height, ) -> CoinbaseSpendRestriction

Returns the transparent::CoinbaseSpendRestriction for this transaction, assuming it is mined at spend_height.

impl Transaction

pub fn test_v1( inputs: Vec<Input>, outputs: Vec<Output>, lock_time: LockTime, ) -> Self

Build a V1 transaction from transparent components. Used in tests.

pub fn test_v2( inputs: Vec<Input>, outputs: Vec<Output>, lock_time: LockTime, ) -> Self

Build a V2 transaction from transparent components. Used in tests.

pub fn test_v3( inputs: Vec<Input>, outputs: Vec<Output>, lock_time: LockTime, expiry_height: Height, ) -> Self

Build a V3 (Overwinter) transaction from transparent components. Used in tests.

pub fn test_v4( inputs: Vec<Input>, outputs: Vec<Output>, lock_time: LockTime, expiry_height: Height, ) -> Self

Build a V4 (Sapling) transaction from transparent components. Used in tests.

pub fn test_v5( network_upgrade: NetworkUpgrade, inputs: Vec<Input>, outputs: Vec<Output>, lock_time: LockTime, expiry_height: Height, ) -> Self

Build a V5 (NU5) transaction from transparent components. Used in tests.

pub fn test_v6( network_upgrade: NetworkUpgrade, inputs: Vec<Input>, outputs: Vec<Output>, lock_time: LockTime, expiry_height: Height, ) -> Self

Build a transparent-only V6 transaction, for tests.

fn build_transparent( version: TxVersion, branch_id: BranchId, lock_time: u32, expiry_height: BlockHeight, inputs: Vec<Input>, outputs: Vec<Output>, ) -> Self

pub fn test_v5_with_orchard( network_upgrade: NetworkUpgrade, inputs: Vec<Input>, outputs: Vec<Output>, lock_time: LockTime, expiry_height: Height, orchard_bundle: Option<Bundle<Authorized, ZatBalance>>, ) -> Self

Build a V5 transaction with an Orchard bundle, for tests.

The bundle must have been constructed for [orchard::bundle::BundleVersion::orchard_v2] or [orchard::bundle::BundleVersion::orchard_v3], matching network_upgrade.

pub fn test_v6_with_bundles( network_upgrade: NetworkUpgrade, inputs: Vec<Input>, outputs: Vec<Output>, lock_time: LockTime, expiry_height: Height, orchard_bundle: Option<Bundle<Authorized, ZatBalance>>, ironwood_bundle: Option<Bundle<Authorized, ZatBalance>>, ) -> Self

Build a V6 transaction with Orchard and Ironwood bundles, for tests.

orchard_bundle must have been constructed for [orchard::bundle::BundleVersion::orchard_v3] and ironwood_bundle for [orchard::bundle::BundleVersion::ironwood_v3]; the two slots are not interchangeable.

fn transparent_bundle_from( inputs: Vec<Input>, outputs: Vec<Output>, ) -> Option<Bundle<Authorized>>

Converts Zebra transparent inputs and outputs into a librustzcash bundle, returning None if both are empty.

pub fn with_transparent_inputs(self, inputs: Vec<Input>) -> Self

Rebuild this transaction with new transparent inputs.

pub fn with_transparent_outputs(self, outputs: Vec<Output>) -> Self

Rebuild this transaction with new transparent outputs.

fn rebuild_with_transparent( self, transparent_bundle: Option<Bundle<Authorized>>, ) -> Self

pub fn set_expiry_height(&mut self, height: Height)

Rebuild this transaction with a different expiry height (recomputes txid).

pub fn set_network_upgrade(&mut self, nu: NetworkUpgrade)

Rebuild this transaction with a different network upgrade / branch ID (recomputes txid).

pub fn set_outputs(&mut self, outputs: Vec<Output>)

Replace all transparent outputs (recomputes txid).

pub fn with_orchard_bundle( self, bundle: Option<Bundle<Authorized, ZatBalance>>, ) -> Self

Rebuild this transaction with a replaced Orchard bundle (recomputes txid).

Test helper for synthesizing transactions with malformed orchard data (e.g. duplicated actions) that would otherwise be unreachable through normal construction paths.

pub fn test_v4_with_joinsplit_data( joinsplit_data: Option<&JoinSplitData<Groth16Proof>>, ) -> Self

Build a V4 transaction with optional JoinSplit data via byte-level serialization.

Transparent inputs/outputs and sapling shielded data are empty. Used by tests that need V4 transactions with sprout data.

Methods from Deref<Target = TransactionData<Authorized>>

pub fn version(&self) -> TxVersion

Returns the transaction version.

pub fn consensus_branch_id(&self) -> BranchId

Returns the Zcash epoch that this transaction can be mined in.

pub fn lock_time(&self) -> u32

pub fn expiry_height(&self) -> BlockHeight

pub fn transparent_bundle( &self, ) -> Option<&Bundle<<A as Authorization>::TransparentAuth>>

pub fn sprout_bundle(&self) -> Option<&Bundle>

pub fn sapling_bundle( &self, ) -> Option<&Bundle<<A as Authorization>::SaplingAuth, ZatBalance>>

pub fn orchard_bundle( &self, ) -> Option<&Bundle<<A as Authorization>::OrchardAuth, ZatBalance>>

pub fn ironwood_bundle( &self, ) -> Option<&Bundle<<A as Authorization>::OrchardAuth, ZatBalance>>

pub fn fee_paid<E, F>(&self, get_prevout: F) -> Result<Option<Zatoshis>, E>

where E: From<BalanceError>, F: FnMut(&OutPoint) -> Result<Option<Zatoshis>, E>,

Returns the total fees paid by the transaction, given a function that can be used to retrieve the value of previous transactions’ transparent outputs that are being spent in this transaction.

pub fn digest<D>(&self, digester: D) -> <D as TransactionDigest<A>>::Digest

where D: TransactionDigest<A>,

Computes this transaction’s digest using the provided digest strategy.

Version 6 transactions include the Ironwood bundle digest as a separate Orchard-shaped digest with Ironwood personalization. Earlier transaction versions do not include Ironwood in their digest.

pub fn sapling_value_balance(&self) -> ZatBalance

Trait Implementations

impl Arbitrary for Transaction

type Parameters = LedgerState

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = BoxedStrategy<Transaction>

The type of Strategy used to generate values of type Self.

fn arbitrary_with(ledger_state: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl Clone for Transaction

fn clone(&self) -> Self

Returns a duplicate 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 Deref for Transaction

type Target = TransactionData<Authorized>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Display for Transaction

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

Formats the value using the given formatter.

impl Eq for Transaction

impl From<&Transaction> for WtxId

fn from(transaction: &Transaction) -> Self

Computes the witnessed transaction ID for a transaction.

Panics

If passed a pre-v5 transaction.

impl From<&Transaction> for Hash

fn from(transaction: &Transaction) -> Self

Converts to this type from the input type.

impl From<&Transaction> for UnminedTxId

fn from(transaction: &Transaction) -> Self

Converts to this type from the input type.

impl From<Transaction> for Hash

fn from(transaction: Transaction) -> Self

Converts to this type from the input type.

impl From<Transaction> for UnminedTxId

fn from(transaction: Transaction) -> Self

Converts to this type from the input type.

impl PartialEq for Transaction

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Transaction

Available on crate features elasticsearch or proptest-impl only.

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl TrustedPreallocate for Transaction

No valid Zcash message contains more transactions than can fit in a single block

tx messages contain a single transaction, and block messages are limited to the maximum block size.

fn max_allocation() -> u64

Provides a loose upper bound on the size of the Vec<T: TrustedPreallocate> which can possibly be received from an honest peer.

impl TryFrom<&Transaction> for AuthDigest

fn try_from(transaction: &Transaction) -> Result<Self, Self::Error>

Computes the authorizing data commitment for a transaction.

Returns an error if passed a pre-V5 transaction (which has no auth digest).

type Error = &'static str

The type returned in the event of a conversion error.

impl ZcashDeserialize for Transaction

fn zcash_deserialize<R: Read>(reader: R) -> Result<Self, SerializationError>

Deserialize a transaction without network context.

Branch ID handling

• V5+ transactions: the consensus branch ID is read from the wire. Correct.
• V1-V4 transactions: the branch ID is NOT on the wire, so a default (BranchId::Canopy) is stored. This does not affect parsing or txid computation, but the stored consensus_branch_id field will be wrong for transactions mined before Canopy. Use ZcashDeserializeWithContext<BranchId> when the correct branch ID is known.

Callers

Prefer ZcashDeserializeWithContext<BranchId> when the correct branch ID is known. This context-free impl exists for:

• Block deserialization (branch ID is corrected afterward)
• Network message parsing and RPC (transactions are re-validated with the correct branch ID before sighash computation)

impl ZcashDeserializeWithContext<BranchId> for Transaction

fn zcash_deserialize_with_context<R: Read>( reader: R, branch_id: &BranchId, ) -> Result<Self, SerializationError>

Deserialize a transaction with a known consensus branch ID.

Runs the same parse-time consensus checks as Transaction::zcash_deserialize.

impl ZcashSerialize for Transaction

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

Write self to the given writer using the canonical format.

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

Helper function to construct a vec to serialize the current struct into

fn zcash_serialized_size(&self) -> usize

Get the size of self by using a fake writer.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 2760 bytes