Enum WormholeCommands 

pub enum WormholeCommands {
    Address {
        secret: String,
    },
    Prove {
        secret: String,
        amount: u128,
        exit_account: String,
        block: String,
        transfer_count: u64,
        funding_account: String,
        output: String,
    },
    Aggregate {
        proofs: Vec<String>,
        output: String,
    },
    VerifyAggregated {
        proof: String,
    },
    ParseProof {
        proof: String,
        aggregated: bool,
        verify: bool,
    },
    Multiround {
        num_proofs: usize,
        rounds: usize,
        amount: f64,
        wallet: String,
        password: Option<String>,
        password_file: Option<String>,
        keep_files: bool,
        output_dir: String,
        dry_run: bool,
    },
    Dissolve {
        amount: f64,
        target_size: f64,
        wallet: String,
        password: Option<String>,
        password_file: Option<String>,
        keep_files: bool,
        output_dir: String,
    },
    Fuzz {
        wallet: String,
        password: Option<String>,
        password_file: Option<String>,
        amount: f64,
    },
}

Variants

Address

Derive the unspendable wormhole address from a secret

Fields

secret: String

Secret (32-byte hex string) - used to derive the unspendable account

Prove

Generate a wormhole proof from an existing transfer

Fields

secret: String

Secret (32-byte hex string) used for the transfer

amount: u128

Funding amount that was transferred

exit_account: String

Exit account (where funds will be withdrawn, hex or SS58)

block: String

Block hash to generate proof against (hex)

transfer_count: u64

Transfer count from the transfer event

funding_account: String

Funding account (sender of transfer, hex or SS58)

output: String

Output file for the proof (default: proof.hex)

Aggregate

Aggregate multiple wormhole proofs into a single proof

Fields

proofs: Vec<String>

Input proof files (hex-encoded)

output: String

Output file for the aggregated proof (default: aggregated_proof.hex)

VerifyAggregated

Verify an aggregated wormhole proof on-chain

Fields

proof: String

Path to the aggregated proof file (hex-encoded)

ParseProof

Parse and display the contents of a proof file (for debugging)

Fields

proof: String

Path to the proof file (hex-encoded)

aggregated: bool

Parse as aggregated proof (default: false, parses as leaf proof)

verify: bool

Verify the proof cryptographically (local verification, not on-chain)

Multiround

Run a multi-round wormhole test: wallet -> wormhole -> … -> wallet

Fields

num_proofs: usize

Number of proofs per round (default: 2, max: 8)

rounds: usize

Number of rounds (default: 2)

amount: f64

Total amount in DEV to partition across all proofs (default: 100)

wallet: String

Wallet name to use for funding and final exit

password: Option<String>

Password for the wallet

password_file: Option<String>

Read password from file

keep_files: bool

Keep proof files after completion

output_dir: String

Output directory for proof files

dry_run: bool

Dry run - show what would be done without executing

Dissolve

Dissolve a large wormhole deposit into many small outputs for better privacy.

Creates a tree of wormhole transactions: each layer splits outputs into two, doubling the number of outputs until all are below the target size. This moves funds from a high-amount bucket (few deposits, low privacy score) into the low-amount bucket (many miner rewards, high privacy score).

Fields

amount: f64

Amount in DEV to dissolve

target_size: f64

Target output size in DEV (stop splitting when all outputs are below this)

wallet: String

Wallet name to use for funding

password: Option<String>

Password for the wallet

password_file: Option<String>

Read password from file

keep_files: bool

Keep proof files after completion

output_dir: String

Output directory for proof files

Fuzz

Fuzz test the leaf verification by attempting invalid proofs

Fields

wallet: String

Wallet name to use for funding

password: Option<String>

Password for the wallet

password_file: Option<String>

Read password from file

amount: f64

Amount in DEV to use for the test transfer (default: 1.0)

Trait Implementations

impl Debug for WormholeCommands

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

Formats the value using the given formatter.

impl FromArgMatches for WormholeCommands

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Subcommand for WormholeCommands

fn augment_subcommands<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_subcommands_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand