Struct penumbra_transaction::plan::TransactionPlan

pub struct TransactionPlan {
    pub actions: Vec<ActionPlan>,
    pub expiry_height: u64,
    pub chain_id: String,
    pub fee: Fee,
    pub clue_plans: Vec<CluePlan>,
    pub memo_plan: Option<MemoPlan>,
}

A declaration of a planned Transaction, for use in transaction authorization and creation.

Fields

actions: Vec<ActionPlan>

A list of this transaction’s actions.

expiry_height: u64

chain_id: String

fee: Fee

clue_plans: Vec<CluePlan>

memo_plan: Option<MemoPlan>

Implementations

impl TransactionPlan

pub fn effect_hash(&self, fvk: &FullViewingKey) -> EffectHash

Computes the EffectHash for the Transaction described by this TransactionPlan.

This method does not require constructing the entire Transaction, but it does require the associated FullViewingKey to derive effecting data that will be fed into the EffectHash.

impl TransactionPlan

pub fn authorize<R: RngCore + CryptoRng>( &self, rng: R, sk: &SpendKey ) -> AuthorizationData

Authorize this TransactionPlan with the provided SpendKey.

The returned AuthorizationData can be used to build a Transaction.

impl TransactionPlan

pub fn build( self, fvk: &FullViewingKey, witness_data: WitnessData ) -> Result<UnauthTransaction>

Build the transaction this plan describes.

To turn a transaction plan into an unauthorized transaction, we need:

• fvk, the FullViewingKey for the source funds;
• witness_data, the WitnessData used for proving;

pub async fn build_concurrent<R: CryptoRng + RngCore>( self, rng: R, fvk: &FullViewingKey, witness_data: WitnessData ) -> Result<UnauthTransaction>

Build the transaction this plan describes while proving concurrently. This can be used in environments that support tokio tasks.

impl TransactionPlan

pub fn spend_plans(&self) -> impl Iterator<Item = &SpendPlan>

pub fn output_plans(&self) -> impl Iterator<Item = &OutputPlan>

pub fn clue_plans(&self) -> impl Iterator<Item = &CluePlan>

pub fn delegations(&self) -> impl Iterator<Item = &Delegate>

pub fn undelegations(&self) -> impl Iterator<Item = &Undelegate>

pub fn undelegate_claim_plans( &self ) -> impl Iterator<Item = &UndelegateClaimPlan>

pub fn ibc_actions(&self) -> impl Iterator<Item = &IbcAction>

pub fn validator_definitions(&self) -> impl Iterator<Item = &Definition>

pub fn proposal_submits(&self) -> impl Iterator<Item = &ProposalSubmit>

pub fn proposal_withdraws(&self) -> impl Iterator<Item = &ProposalWithdraw>

pub fn delegator_vote_plans(&self) -> impl Iterator<Item = &DelegatorVotePlan>

pub fn validator_votes(&self) -> impl Iterator<Item = &ValidatorVote>

pub fn proposal_deposit_claims( &self ) -> impl Iterator<Item = &ProposalDepositClaim>

pub fn swap_plans(&self) -> impl Iterator<Item = &SwapPlan>

pub fn swap_claim_plans(&self) -> impl Iterator<Item = &SwapClaimPlan>

pub fn dao_spends(&self) -> impl Iterator<Item = &DaoSpend>

pub fn dao_deposits(&self) -> impl Iterator<Item = &DaoDeposit>

pub fn dao_outputs(&self) -> impl Iterator<Item = &DaoOutput>

pub fn position_openings(&self) -> impl Iterator<Item = &PositionOpen>

pub fn position_closings(&self) -> impl Iterator<Item = &PositionClose>

pub fn position_withdrawals( &self ) -> impl Iterator<Item = &PositionWithdrawPlan>

pub fn ics20_withdrawals(&self) -> impl Iterator<Item = &Ics20Withdrawal>

pub fn dest_addresses(&self) -> Vec<Address>

Convenience method to get all the destination addresses for each OutputPlans.

pub fn num_outputs(&self) -> usize

Convenience method to get the number of OutputPlans in this transaction.

pub fn add_all_clue_plans<R: CryptoRng + Rng>( &mut self, rng: R, precision_bits: usize )

Method to add CluePlans to a TransactionPlan.

Trait Implementations

impl Clone for TransactionPlan

fn clone(&self) -> TransactionPlan

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TransactionPlan

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

Formats the value using the given formatter.

impl Default for TransactionPlan

fn default() -> TransactionPlan

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TransactionPlan

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl DomainType for TransactionPlan

type Proto = TransactionPlan

fn encode_to_vec(&self) -> Vec<u8, Global>

Encode this domain type to a byte vector, via proto type P.

fn to_proto(&self) -> Self::Proto

Convert this domain type to the associated proto type.

fn decode<B>(buf: B) -> Result<Self, Error>where B: Buf,

Decode this domain type from a byte buffer, via proto type P.

impl From<TransactionPlan> for TransactionPlan

fn from(msg: TransactionPlan) -> Self

Converts to this type from the input type.

impl Serialize for TransactionPlan

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<TransactionPlan> for TransactionPlan

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: TransactionPlan) -> Result<Self, Self::Error>

Performs the conversion.

impl TypeUrl for TransactionPlan

const TYPE_URL: &'static str = "/penumbra.core.transaction.v1alpha1.TransactionPlan"