Struct ProofGenerationInput 

pub struct ProofGenerationInput {

    pub secret: [u8; 32],
    pub transfer_count: u64,
    pub funding_account: [u8; 32],
    pub wormhole_address: [u8; 32],
    pub funding_amount: u128,
    pub block_hash: [u8; 32],
    pub block_number: u32,
    pub parent_hash: [u8; 32],
    pub state_root: [u8; 32],
    pub extrinsics_root: [u8; 32],
    pub digest: Vec<u8>,
    pub proof_nodes: Vec<Vec<u8>>,
    pub exit_account_1: [u8; 32],
    pub exit_account_2: [u8; 32],
    pub output_amount_1: u32,
    pub output_amount_2: u32,
    pub volume_fee_bps: u32,
    pub asset_id: u32,
}

Input data for generating a wormhole proof. All fields are raw bytes - no chain client required.

Fields

secret: [u8; 32]

32-byte secret

transfer_count: u64

Transfer count (atomic counter per recipient)

funding_account: [u8; 32]

Funding account (sender) as 32 bytes

wormhole_address: [u8; 32]

Wormhole address (recipient/unspendable account) as 32 bytes

funding_amount: u128

Funding amount in planck (12 decimals)

block_hash: [u8; 32]

Block hash as 32 bytes

block_number: u32

Block number

parent_hash: [u8; 32]

Parent hash as 32 bytes

state_root: [u8; 32]

State root as 32 bytes

extrinsics_root: [u8; 32]

Extrinsics root as 32 bytes

digest: Vec<u8>

SCALE-encoded digest (variable length, padded to 110 bytes internally)

proof_nodes: Vec<Vec<u8>>

Storage proof nodes (each node is a Vec)

exit_account_1: [u8; 32]

Exit account 1 as 32 bytes

exit_account_2: [u8; 32]

Exit account 2 as 32 bytes (use zeros for single output)

output_amount_1: u32

Output amount 1 (quantized, 2 decimals)

output_amount_2: u32

Output amount 2 (quantized, 2 decimals, 0 for single output)

volume_fee_bps: u32

Volume fee in basis points

asset_id: u32

Asset ID (0 for native token)

Trait Implementations

impl Clone for ProofGenerationInput

fn clone(&self) -> ProofGenerationInput

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProofGenerationInput

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

Formats the value using the given formatter.