Struct SwapClaimPlan

pub struct SwapClaimPlan {
    pub swap_plaintext: SwapPlaintext,
    pub position: Position,
    pub output_data: BatchSwapOutputData,
    pub epoch_duration: u64,
    pub proof_blinding_r: Fq,
    pub proof_blinding_s: Fq,
}

A planned SwapClaim.

Fields

swap_plaintext: SwapPlaintext

position: Position

output_data: BatchSwapOutputData

epoch_duration: u64

proof_blinding_r: Fq

The first blinding factor used for generating the ZK proof.

proof_blinding_s: Fq

The second blinding factor used for generating the ZK proof.

Implementations

impl SwapClaimPlan

pub fn swap_claim( &self, fvk: &FullViewingKey, state_commitment_proof: &Proof, ) -> SwapClaim

Convenience method to construct the SwapClaim described by this SwapClaimPlan.

pub fn swap_claim_proof( &self, state_commitment_proof: &Proof, fvk: &FullViewingKey, ) -> SwapClaimProof

Construct the SwapClaimProof required by the swap_claim::Body described by this plan.

pub fn swap_claim_body(&self, fvk: &FullViewingKey) -> Body

Construct the swap_claim::Body described by this plan.

pub fn is_viewed_by(&self, ivk: &IncomingViewingKey) -> bool

Checks whether this plan’s output is viewed by the given IVK.

pub fn balance(&self) -> Balance

Trait Implementations

impl Clone for SwapClaimPlan

fn clone(&self) -> SwapClaimPlan

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SwapClaimPlan

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SwapClaimPlan

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl DomainType for SwapClaimPlan

type Proto = SwapClaimPlan

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

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<SwapClaimPlan> for SwapClaimPlan

fn from(msg: SwapClaimPlan) -> Self

Converts to this type from the input type.

impl Serialize for SwapClaimPlan

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<SwapClaimPlan> for SwapClaimPlan

type Error = Error

The type returned in the event of a conversion error.

fn try_from(msg: SwapClaimPlan) -> Result<Self, Self::Error>

Performs the conversion.