Struct Step 

pub struct Step<NoteRef> { /* private fields */ }

The inputs to be consumed and outputs to be produced in a proposed transaction.

Implementations

impl<NoteRef> Step<NoteRef>

pub fn from_parts( prior_steps: &[Step<NoteRef>], transaction_request: TransactionRequest, payment_pools: BTreeMap<usize, PoolType>, transparent_inputs: Vec<WalletTransparentOutput<()>>, shielded_inputs: Option<ShieldedInputs<NoteRef>>, anchor_height: Option<BlockHeight>, prior_step_inputs: Vec<StepOutput>, balance: TransactionBalance, is_shielding: bool, ironwood_active: bool, ) -> Result<Self, ProposalError>

Constructs a validated Step from its constituent parts.

This operation validates the proposal for balance consistency and agreement between the is_shielding flag and the structure of the proposal.

Parameters:

• transaction_request: The ZIP 321 transaction request describing the payments to be made.
• payment_pools: A map from payment index to pool type. The set of payment indices provided here must exactly match the set of payment indices in the TransactionRequest, and the selected pool for an index must correspond to a valid receiver of the address at that index (or the address itself in the case of bare transparent or Sapling addresses).
• transparent_inputs: The set of previous transparent outputs to be spent.
• shielded_inputs: The sets of previous shielded outputs to be spent.
• anchor_height: The anchor height that binds every shielded-tree lookup performed while building this step’s transaction — both shielded-input witnesses and shielded-output anchors. A step that produces a shielded bundle (spends shielded notes, pays to a shielded pool, or returns shielded change) must provide Some; only a purely transparent step may pass None.
• balance: The change outputs to be added the transaction and the fee to be paid.
• is_shielding: A flag that identifies whether this is a wallet-internal shielding transaction.
• ironwood_active: Whether the Ironwood pool is active at the target height for which this step is proposed. When active, the step is checked against the Orchard turnstile: no payment may be directed to the Orchard pool, and change may be returned to it only when strictly less value returns than the step’s Orchard inputs remove.

pub fn transaction_request(&self) -> &TransactionRequest

Returns the transaction request that describes the payments to be made.

pub fn payment_pools(&self) -> &BTreeMap<usize, PoolType>

Returns the map from payment index to the pool that has been selected for the output that will fulfill that payment.

pub fn transparent_inputs(&self) -> &[WalletTransparentOutput<()>]

Returns the transparent inputs that have been selected to fund the transaction.

pub fn shielded_inputs(&self) -> Option<&ShieldedInputs<NoteRef>>

Returns the shielded inputs that have been selected to fund the transaction.

pub fn anchor_height(&self) -> Option<BlockHeight>

Returns the anchor height that binds every shielded-tree lookup performed while building this step’s transaction, or None for a purely transparent step that performs no such lookup.

pub fn prior_step_inputs(&self) -> &[StepOutput]

Returns the inputs that should be obtained from the outputs of the transaction created to satisfy a previous step of the proposal.

pub fn balance(&self) -> &TransactionBalance

Returns the change outputs to be added to the transaction and the fee to be paid.

pub fn is_shielding(&self) -> bool

Returns a flag indicating whether or not the proposed transaction is exclusively wallet-internal (if it does not involve any external recipients).

pub fn involves(&self, pool_type: PoolType) -> bool

Returns whether or not this proposal requires interaction with the specified pool.

pub fn input_in_pool(&self, pool_type: PoolType) -> bool

Returns whether or not this step spends any inputs from the given pool.

For a shielded pool this is true when a note of that protocol is spent; for [PoolType::Transparent] it is true when the step is a shielding step or has any transparent inputs.

pub fn output_in_pool(&self, pool_type: PoolType) -> bool

Returns whether or not this step directs any payment output to the given pool.

This does not consider change outputs; use Step::change_in_pool for those.

pub fn change_in_pool(&self, pool_type: PoolType) -> bool

Returns whether or not this step directs any change output to the given pool.

pub fn input_count_in_pool(&self, pool_type: PoolType) -> usize

Returns the number of inputs to this step that belong to the given pool.

For a shielded pool this is the number of spent notes of that protocol; for [PoolType::Transparent] it is the number of transparent inputs.

pub fn output_count_in_pool(&self, pool_type: PoolType) -> usize

Returns the number of payment outputs of this step that are directed to the given pool.

This does not include change outputs; use Step::change_count_in_pool for those.

pub fn change_count_in_pool(&self, pool_type: PoolType) -> usize

Returns the number of change outputs of this step that are directed to the given pool.

pub fn is_canonical_crossing<P: PoolMigrationConstants>( &self, params: &P, canonical_fee: Zatoshis, ) -> bool

Available on crate feature orchard only.

Returns whether this step is a canonical crossing: a step whose whole shape is indistinguishable from a ZIP 318 migration transfer, and which is therefore built with a single unpadded Ironwood action so that it joins that anonymity set. See Step::ironwood_bundle_padding.

A migration transfer spends one Orchard note, pads its Orchard bundle to the default two-action floor (the spend plus its change, or a dummy when the note’s value exactly covers the crossing and its fee), outputs one canonical denomination into the Ironwood pool, and is proved against a boundary of the anchor bucket grid. Every one of those is required here:

• exactly one Orchard input and at most one Orchard change output, so that the Orchard bundle is exactly two actions;
• no change in any other pool;
• no Ironwood spends, a step funded from Ironwood crossing nothing;
• no Ironwood change, leaving a single Ironwood output;
• that output’s value is a canonical denomination under params;
• the step’s anchor lies on params’ anchor bucket grid;
• the fee equals canonical_fee, which the caller obtains from fees::canonical_crossing_fee for the consensus parameters and target height the transaction will actually be built against.

Dropping the Ironwood padding without the rest would not buy anonymity but destroy it: an unpadded Ironwood bundle beside an Orchard bundle of the wrong size, or against a chain-tip anchor, is a shape nothing else on the network emits — a fingerprint rather than a disguise.

pub fn ironwood_bundle_padding(&self) -> BundlePadding

Available on crate feature orchard only.

The transactional bundle padding the transaction builder must use for this step’s Ironwood bundle: the padding the ChangeStrategy recorded when it computed the fee.

This is READ, not re-derived. The builder must produce exactly the action count the fee was charged against, and a second derivation could disagree with the first — which is precisely what happens for a condition only one of them can evaluate, such as whether the resulting fee is itself canonical.

pub fn orchard_action_count( &self, padding: BundlePadding, bundle_version: BundleVersion, ) -> Result<usize, &'static str>

Available on crate feature orchard only.

Returns the number of actions the transaction builder will produce for this step’s Orchard-pool bundle, given the bundle padding and version it will be configured with.

The count depends upon the bundle version: prior to NU6.3, an action may carry both a spend and an output, so a bundle requires max(spends, outputs) actions; from NU6.3 onwards the Orchard pool disables cross-address transfers, and each requested spend and output is instead paired with a fabricated zero-valued counterpart, so a bundle requires spends + outputs actions. The padding determines the floor applied on top of that count.

The caller must pass the same padding and version the transaction builder will be configured with, otherwise the count will not match the bundle that is built. bundle_version_for_branch returns the version applicable to a given consensus branch and pool. The Orchard bundle is always padded to the default floor; only the Ironwood bundle’s padding varies, and Step::ironwood_bundle_padding derives it.

A step describes a wallet spend, which is never a coinbase transaction, so this takes a [BundlePadding] rather than a full bundle type: coinbase construction is a property of the whole transaction and is not representable here.

Errors

Returns an error if this step’s Orchard spend and output counts are incompatible with the given padding and version.

pub fn ironwood_action_count( &self, padding: BundlePadding, bundle_version: BundleVersion, ) -> Result<usize, &'static str>

Available on crate feature orchard only.

Returns the number of actions the transaction builder will produce for this step’s Ironwood-pool bundle, given the bundle padding and version it will be configured with.

See Step::orchard_action_count for how the count is determined; the Ironwood pool permits cross-address transfers, so an Ironwood bundle requires max(spends, outputs) actions before padding.

Errors

Returns an error if this step’s Ironwood spend and output counts are incompatible with the given padding and version.

Trait Implementations

impl<NoteRef: Clone> Clone for Step<NoteRef>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<NoteRef> Debug for Step<NoteRef>

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

Formats the value using the given formatter.

impl<NoteRef: Eq> Eq for Step<NoteRef>

impl<NoteRef: PartialEq> PartialEq for Step<NoteRef>

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

Equality operator ==.

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

Inequality operator !=.

impl<NoteRef: PartialEq> StructuralPartialEq for Step<NoteRef>