Enum sui::client_commands::SuiClientCommands

pub enum SuiClientCommands {
    ActiveAddress,
    ActiveEnv,
    Addresses {
        sort_by_alias: bool,
    },
    Balance {
        address: Option<KeyIdentity>,
        coin_type: Option<String>,
        with_coins: bool,
    },
    Call {
        package: ObjectID,
        module: String,
        function: String,
        type_args: Vec<TypeTag>,
        args: Vec<SuiJsonValue>,
        gas_price: Option<u64>,
        opts: OptsWithGas,
    },
    ChainIdentifier,
    DynamicFieldQuery {
        id: ObjectID,
        cursor: Option<ObjectID>,
        limit: usize,
    },
    Envs,
    ExecuteSignedTx {
        tx_bytes: String,
        signatures: Vec<String>,
    },
    ExecuteCombinedSignedTx {
        signed_tx_bytes: String,
    },
    Faucet {
        address: Option<KeyIdentity>,
        url: Option<String>,
    },
    Gas {
        address: Option<KeyIdentity>,
    },
    MergeCoin {
        primary_coin: ObjectID,
        coin_to_merge: ObjectID,
        opts: OptsWithGas,
    },
    NewAddress {
        key_scheme: SignatureScheme,
        alias: Option<String>,
        word_length: Option<String>,
        derivation_path: Option<DerivationPath>,
    },
    NewEnv {
        alias: String,
        rpc: String,
        ws: Option<String>,
    },
    Object {
        id: ObjectID,
        bcs: bool,
    },
    Objects {
        address: Option<KeyIdentity>,
    },
    Pay {
        input_coins: Vec<ObjectID>,
        recipients: Vec<KeyIdentity>,
        amounts: Vec<u64>,
        opts: OptsWithGas,
    },
    PayAllSui {
        input_coins: Vec<ObjectID>,
        recipient: KeyIdentity,
        opts: Opts,
    },
    PaySui {
        input_coins: Vec<ObjectID>,
        recipients: Vec<KeyIdentity>,
        amounts: Vec<u64>,
        opts: Opts,
    },
    PTB(PTB),
    Publish {
        package_path: PathBuf,
        build_config: BuildConfig,
        opts: OptsWithGas,
        skip_dependency_verification: bool,
        with_unpublished_dependencies: bool,
    },
    SplitCoin {
        coin_id: ObjectID,
        amounts: Option<Vec<u64>>,
        count: Option<u64>,
        opts: OptsWithGas,
    },
    Switch {
        address: Option<KeyIdentity>,
        env: Option<String>,
    },
    TransactionBlock {
        digest: TransactionDigest,
    },
    Transfer {
        to: KeyIdentity,
        object_id: ObjectID,
        opts: OptsWithGas,
    },
    TransferSui {
        to: KeyIdentity,
        sui_coin_object_id: ObjectID,
        amount: Option<u64>,
        opts: Opts,
    },
    Upgrade {
        package_path: PathBuf,
        upgrade_capability: ObjectID,
        build_config: BuildConfig,
        opts: OptsWithGas,
        skip_dependency_verification: bool,
        with_unpublished_dependencies: bool,
    },
    VerifyBytecodeMeter {
        package_path: Option<PathBuf>,
        protocol_version: Option<u64>,
        module_paths: Vec<PathBuf>,
        build_config: BuildConfig,
    },
    VerifySource {
        package_path: PathBuf,
        build_config: BuildConfig,
        verify_deps: bool,
        skip_source: bool,
        address_override: Option<ObjectID>,
    },
    ProfileTransaction {
        tx_digest: String,
        profile_output: Option<PathBuf>,
    },
    ReplayTransaction {
        tx_digest: String,
        gas_info: bool,
        ptb_info: bool,
        executor_version: Option<i64>,
        protocol_version: Option<i64>,
    },
    ReplayBatch {
        path: PathBuf,
        terminate_early: bool,
    },
    ReplayCheckpoints {
        start: u64,
        end: u64,
        terminate_early: bool,
    },
}

Variants

ActiveAddress

Default address used for commands when none specified

ActiveEnv

Default environment used for commands when none specified

Addresses

Fields

sort_by_alias: bool

Sort by alias instead of address

Obtain the Addresses managed by the client.

Balance

Fields

address: Option<KeyIdentity>

Address (or its alias)

coin_type: Option<String>

Show balance for the specified coin (e.g., 0x2::sui::SUI). All coins will be shown if none is passed.

with_coins: bool

Show a list with each coin’s object ID and balance

List the coin balance of an address

Call

Fields

package: ObjectID

Object ID of the package, which contains the module

module: String

The name of the module in the package

function: String

Function name in module

type_args: Vec<TypeTag>

Type arguments to the generic function being called. All must be specified, or the call will fail.

args: Vec<SuiJsonValue>

Simplified ordered args like in the function syntax ObjectIDs, Addresses must be hex strings

gas_price: Option<u64>

Optional gas price for this call. Currently use only for testing and not in production environments.

opts: OptsWithGas

Call Move function

ChainIdentifier

Query the chain identifier from the rpc endpoint.

DynamicFieldQuery

Fields

id: ObjectID

The ID of the parent object

cursor: Option<ObjectID>

Optional paging cursor

limit: usize

Maximum item returned per page

Query a dynamic field by its address.

Envs

List all Sui environments

ExecuteSignedTx

Fields

tx_bytes: String

BCS serialized transaction data bytes without its type tag, as base64 encoded string. This is the output of sui client command using –serialize-unsigned-transaction.

signatures: Vec<String>

A list of Base64 encoded signatures flag || signature || pubkey.

Execute a Signed Transaction. This is useful when the user prefers to sign elsewhere and use this command to execute.

ExecuteCombinedSignedTx

Fields

signed_tx_bytes: String

BCS serialized sender signed data, as base64 encoded string. This is the output of sui client command using –serialize-signed-transaction.

Execute a combined serialized SenderSignedData string.

Faucet

Fields

address: Option<KeyIdentity>

Address (or its alias)

url: Option<String>

The url to the faucet

Request gas coin from faucet. By default, it will use the active address and the active network.

Gas

Fields

address: Option<KeyIdentity>

Address (or its alias) owning the objects

Obtain all gas objects owned by the address. An address’ alias can be used instead of the address.

MergeCoin

Fields

primary_coin: ObjectID

The address of the coin to merge into.

coin_to_merge: ObjectID

The address of the coin to be merged.

opts: OptsWithGas

Merge two coin objects into one coin

NewAddress

Fields

key_scheme: SignatureScheme

alias: Option<String>

The alias must start with a letter and can contain only letters, digits, hyphens (-), or underscores (_).

word_length: Option<String>

derivation_path: Option<DerivationPath>

Generate new address and keypair with keypair scheme flag {ed25519 | secp256k1 | secp256r1} with optional derivation path, default to m/44’/784’/0’/0’/0’ for ed25519 or m/54’/784’/0’/0/0 for secp256k1 or m/74’/784’/0’/0/0 for secp256r1. Word length can be { word12 | word15 | word18 | word21 | word24} default to word12 if not specified.

NewEnv

Fields

alias: String

rpc: String

ws: Option<String>

Add new Sui environment.

Object

Fields

id: ObjectID

Object ID of the object to fetch

bcs: bool

Return the bcs serialized version of the object

Get object info

Objects

Fields

address: Option<KeyIdentity>

Address owning the object. If no address is provided, it will show all objects owned by sui client active-address.

Obtain all objects owned by the address. It also accepts an address by its alias.

Pay

Fields

input_coins: Vec<ObjectID>

The input coins to be used for pay recipients, following the specified amounts.

recipients: Vec<KeyIdentity>

The recipient addresses, must be of same length as amounts. Aliases of addresses are also accepted as input.

amounts: Vec<u64>

The amounts to be paid, following the order of recipients.

opts: OptsWithGas

Pay coins to recipients following specified amounts, with input coins. Length of recipients must be the same as that of amounts.

PayAllSui

Fields

input_coins: Vec<ObjectID>

The input coins to be used for pay recipients, including the gas coin.

recipient: KeyIdentity

The recipient address (or its alias if it’s an address in the keystore).

opts: Opts

Pay all residual SUI coins to the recipient with input coins, after deducting the gas cost. The input coins also include the coin for gas payment, so no extra gas coin is required.

PaySui

Fields

input_coins: Vec<ObjectID>

The input coins to be used for pay recipients, including the gas coin.

recipients: Vec<KeyIdentity>

The recipient addresses, must be of same length as amounts. Aliases of addresses are also accepted as input.

amounts: Vec<u64>

The amounts to be paid, following the order of recipients.

opts: Opts

Pay SUI coins to recipients following following specified amounts, with input coins. Length of recipients must be the same as that of amounts. The input coins also include the coin for gas payment, so no extra gas coin is required.

PTB(PTB)

Run a PTB from the provided args

Publish

Fields

package_path: PathBuf

Path to directory containing a Move package

build_config: BuildConfig

Package build options

opts: OptsWithGas

skip_dependency_verification: bool

Publish the package without checking whether compiling dependencies from source results in bytecode matching the dependencies found on-chain.

with_unpublished_dependencies: bool

Also publish transitive dependencies that have not already been published.

Publish Move modules

SplitCoin

Fields

coin_id: ObjectID

ID of the coin object to split

amounts: Option<Vec<u64>>

Specific amounts to split out from the coin

count: Option<u64>

Count of equal-size coins to split into

opts: OptsWithGas

Split a coin object into multiple coins.

Switch

Fields

address: Option<KeyIdentity>

An address to be used as the active address for subsequent commands. It accepts also the alias of the address.

env: Option<String>

The RPC server URL (e.g., local rpc server, devnet rpc server, etc) to be used for subsequent commands.

Switch active address and network(e.g., devnet, local rpc server).

TransactionBlock

Fields

digest: TransactionDigest

Digest of the transaction block

Get the effects of executing the given transaction block

Transfer

Fields

to: KeyIdentity

Recipient address (or its alias if it’s an address in the keystore)

object_id: ObjectID

ID of the object to transfer

opts: OptsWithGas

Transfer object

TransferSui

Fields

to: KeyIdentity

Recipient address (or its alias if it’s an address in the keystore)

sui_coin_object_id: ObjectID

ID of the coin to transfer. This is also the gas object.

amount: Option<u64>

The amount to transfer, if not specified, the entire coin object will be transferred.

opts: Opts

Transfer SUI, and pay gas with the same SUI coin object. If amount is specified, only the amount is transferred; otherwise the entire object is transferred.

Upgrade

Fields

package_path: PathBuf

Path to directory containing a Move package

upgrade_capability: ObjectID

ID of the upgrade capability for the package being upgraded.

build_config: BuildConfig

Package build options

opts: OptsWithGas

skip_dependency_verification: bool

Publish the package without checking whether compiling dependencies from source results in bytecode matching the dependencies found on-chain.

with_unpublished_dependencies: bool

Also publish transitive dependencies that have not already been published.

Upgrade Move modules

VerifyBytecodeMeter

Fields

package_path: Option<PathBuf>

Path to directory containing a Move package, (defaults to the current directory)

protocol_version: Option<u64>

Protocol version to use for the bytecode verifier (defaults to the latest protocol version)

module_paths: Vec<PathBuf>

Paths to specific pre-compiled module bytecode to verify (instead of an entire package). Multiple modules can be verified by passing multiple –module flags. They will be treated as if they were one package (subject to the overall package limit).

build_config: BuildConfig

Package build options

Run the bytecode verifier on the package

VerifySource

Fields

package_path: PathBuf

Path to directory containing a Move package

build_config: BuildConfig

Package build options

verify_deps: bool

Verify on-chain dependencies.

skip_source: bool

Don’t verify source (only valid if –verify-deps is enabled).

address_override: Option<ObjectID>

If specified, override the addresses for the package’s own modules with this address. Only works for unpublished modules (whose addresses are currently 0x0).

Verify local Move packages against on-chain packages, and optionally their dependencies.

ProfileTransaction

Fields

tx_digest: String

The digest of the transaction to replay

profile_output: Option<PathBuf>

If specified, overrides the filepath of the output profile, for example – /temp/my_profile_name.json will write output to /temp/my_profile_name_{tx_digest}_{unix_timestamp}.json If an output filepath is not specified, it will output a file gas_profile_{tx_digest}_{unix_timestamp}.json to the working directory

Profile the gas usage of a transaction. Unless an output filepath is not specified, outputs a file gas_profile_{tx_digest}_{unix_timestamp}.json which can be opened in a flamegraph tool such as speedscope.

ReplayTransaction

Fields

tx_digest: String

The digest of the transaction to replay

gas_info: bool

Log extra gas-related information

ptb_info: bool

Log information about each programmable transaction command

executor_version: Option<i64>

Optional version of the executor to use, if not specified defaults to the one originally used for the transaction.

protocol_version: Option<i64>

Optional protocol version to use, if not specified defaults to the one originally used for the transaction.

Replay a given transaction to view transaction effects. Set environment variable MOVE_VM_STEP=1 to debug.

ReplayBatch

Fields

path: PathBuf

The path to the file of transaction digests to replay, with one digest per line

terminate_early: bool

If an error is encountered during a transaction, this specifies whether to terminate or continue

Replay transactions listed in a file.

ReplayCheckpoints

Fields

start: u64

The starting checkpoint sequence number of the range of checkpoints to replay

end: u64

The ending checkpoint sequence number of the range of checkpoints to replay

terminate_early: bool

If an error is encountered during a transaction, this specifies whether to terminate or continue

Replay all transactions in a range of checkpoints.

Implementations

impl SuiClientCommands

pub async fn execute( self, context: &mut WalletContext ) -> Result<SuiClientCommandResult, Error>

pub fn switch_env(config: &mut SuiClientConfig, env: &str) -> Result<(), Error>

Trait Implementations

impl CommandFactory for SuiClientCommands

fn command<'b>() -> Command

Build a [Command] that can instantiate Self.

fn command_for_update<'b>() -> Command

Build a [Command] that can update self.

impl FromArgMatches for SuiClientCommands

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 Parser for SuiClientCommands

fn parse() -> Self

Parse from std::env::args_os(), [exit][Error::exit] on error.

fn try_parse() -> Result<Self, Error>

Parse from std::env::args_os(), return Err on error.

fn parse_from<I, T>(itr: I) -> Self

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, [exit][Error::exit] on error.

fn try_parse_from<I, T>(itr: I) -> Result<Self, Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, return Err on error.

fn update_from<I, T>(&mut self, itr: I)

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, [exit][Error::exit] on error.

fn try_update_from<I, T>(&mut self, itr: I) -> Result<(), Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, return Err on error.

impl Subcommand for SuiClientCommands

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

Append to [Command] so it can instantiate Self.

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

Append to [Command] so it can update self.

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand