Struct Bundle 

pub struct Bundle<T: Authorization, V> { /* private fields */ }

A bundle of actions to be applied to the ledger.

Implementations

impl<S: InProgressSignatures, V> Bundle<InProgress<Unproven, S>, V>

pub fn create_proof( self, pk: &ProvingKey, rng: impl RngCore, ) -> Result<Bundle<InProgress<Proof, S>, V>, BuildError>

Available on crate feature circuit only.

Creates the proof for this bundle.

impl<P: Debug, V> Bundle<InProgress<P, Unauthorized>, V>

pub fn prepare<R: RngCore + CryptoRng>( self, rng: R, sighash: [u8; 32], ) -> Bundle<InProgress<P, PartiallyAuthorized>, V>

Loads the sighash into this bundle, preparing it for signing.

This API ensures that all signatures are created over the same sighash.

impl<V> Bundle<InProgress<Proof, Unauthorized>, V>

pub fn apply_signatures<R: RngCore + CryptoRng>( self, rng: R, sighash: [u8; 32], signing_keys: &[SpendAuthorizingKey], ) -> Result<Bundle<Authorized, V>, BuildError>

Applies signatures to this bundle, in order to authorize it.

This is a helper method that wraps Bundle::prepare, Bundle::sign, and Bundle::finalize.

impl<P: Debug, V> Bundle<InProgress<P, PartiallyAuthorized>, V>

pub fn sign<R: RngCore + CryptoRng>( self, rng: R, ask: &SpendAuthorizingKey, ) -> Self

Signs this bundle with the given SpendAuthorizingKey.

This will apply signatures for all notes controlled by this spending key.

pub fn append_signatures( self, signatures: &[Signature<SpendAuth>], ) -> Result<Self, BuildError>

Appends externally computed Signatures.

Each signature will be applied to the one input for which it is valid. An error will be returned if the signature is not valid for any inputs, or if it is valid for more than one input.

impl<V> Bundle<InProgress<Proof, PartiallyAuthorized>, V>

pub fn finalize(self) -> Result<Bundle<Authorized, V>, BuildError>

Finalizes this bundle, enabling it to be included in a transaction.

Returns an error if any signatures are missing.

impl<T: Authorization, V> Bundle<T, V>

pub fn from_parts( actions: NonEmpty<Action<T::SpendAuth>>, flags: Flags, value_balance: V, anchor: Anchor, authorization: T, ) -> Self

Constructs a Bundle from its constituent parts.

pub fn actions(&self) -> &NonEmpty<Action<T::SpendAuth>>

Returns the list of actions that make up this bundle.

pub fn flags(&self) -> &Flags

Returns the Orchard-specific transaction-level flags for this bundle.

pub fn value_balance(&self) -> &V

Returns the net value moved into or out of the Orchard shielded pool.

This is the sum of Orchard spends minus the sum Orchard outputs.

pub fn anchor(&self) -> &Anchor

Returns the root of the Orchard commitment tree that this bundle commits to.

pub fn authorization(&self) -> &T

Returns the authorization for this bundle.

In the case of a Bundle<Authorized>, this is the proof and binding signature.

pub fn try_map_value_balance<V0, E, F: FnOnce(V) -> Result<V0, E>>( self, f: F, ) -> Result<Bundle<T, V0>, E>

Construct a new bundle by applying a transformation that might fail to the value balance.

pub fn map_authorization<R, U: Authorization>( self, context: &mut R, spend_auth: impl FnMut(&mut R, &T, T::SpendAuth) -> U::SpendAuth, step: impl FnOnce(&mut R, T) -> U, ) -> Bundle<U, V>

Transitions this bundle from one authorization state to another.

pub fn try_map_authorization<R, U: Authorization, E>( self, context: &mut R, spend_auth: impl FnMut(&mut R, &T, T::SpendAuth) -> Result<U::SpendAuth, E>, step: impl FnOnce(&mut R, T) -> Result<U, E>, ) -> Result<Bundle<U, V>, E>

Transitions this bundle from one authorization state to another.

pub fn decrypt_outputs_with_keys( &self, keys: &[IncomingViewingKey], ) -> Vec<(usize, IncomingViewingKey, Note, Address, [u8; 512])>

Performs trial decryption of each action in the bundle with each of the specified incoming viewing keys, and returns a vector of each decrypted note plaintext contents along with the index of the action from which it was derived.

pub fn decrypt_output_with_key( &self, action_idx: usize, key: &IncomingViewingKey, ) -> Option<(Note, Address, [u8; 512])>

Performs trial decryption of the action at action_idx in the bundle with the specified incoming viewing key, and returns the decrypted note plaintext contents if successful.

pub fn recover_outputs_with_ovks( &self, keys: &[OutgoingViewingKey], ) -> Vec<(usize, OutgoingViewingKey, Note, Address, [u8; 512])>

Performs trial decryption of each action in the bundle with each of the specified outgoing viewing keys, and returns a vector of each decrypted note plaintext contents along with the index of the action from which it was derived.

pub fn recover_output_with_ovk( &self, action_idx: usize, key: &OutgoingViewingKey, ) -> Option<(Note, Address, [u8; 512])>

Attempts to decrypt the action at the specified index with the specified outgoing viewing key, and returns the decrypted note plaintext contents if successful.

impl<T: Authorization, V: Copy + Into<i64>> Bundle<T, V>

pub fn commitment(&self) -> BundleCommitment

Computes a commitment to the effects of this bundle, suitable for inclusion within a transaction ID.

pub fn binding_validating_key(&self) -> VerificationKey<Binding>

Returns the transaction binding validating key for this bundle.

This can be used to validate the Authorized::binding_signature returned from Bundle::authorization.

impl<V> Bundle<Authorized, V>

pub fn authorizing_commitment(&self) -> BundleAuthorizingCommitment

Computes a commitment to the authorizing data within for this bundle.

This together with Bundle::commitment bind the entire bundle.

pub fn verify_proof(&self, vk: &VerifyingKey) -> Result<(), Error>

Available on crate feature circuit only.

Verifies the proof for this bundle.

impl<V> Bundle<Unbound, V>

pub fn apply_binding_signature<R: RngCore + CryptoRng>( self, sighash: [u8; 32], rng: R, ) -> Option<Bundle<Authorized, V>>

Verifies the given sighash with every spend_auth_sig, and then binds the bundle.

Returns None if the given sighash does not validate against every spend_auth_sig.

Trait Implementations

impl<T: Clone + Authorization, V: Clone> Clone for Bundle<T, V>

where T::SpendAuth: Clone,

fn clone(&self) -> Bundle<T, V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Authorization, V: Debug> Debug for Bundle<T, V>

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

Formats the value using the given formatter.

impl<V: DynamicUsage> DynamicUsage for Bundle<Authorized, V>

Available on crate feature std only.

fn dynamic_usage(&self) -> usize

Returns a best estimate of the amount of heap-allocated memory used by this type.

fn dynamic_usage_bounds(&self) -> (usize, Option<usize>)

Returns the lower and upper bounds on the amount of heap-allocated memory used by this type.