# Sui Client CLI *[Documentation index](/llms.txt) · [Full index](/llms-full.txt)* The Sui CLI `client` command provides command-level access to interact with the Sui network. Typical uses for `sui client` include publishing Move smart contracts, getting the information of an object, executing transactions, or managing addresses. ## Check Sui CLI installation Before you can use the Sui CLI, you must install it. To check if the CLI exists on your system, open a terminal or console and type the following command: ```sh $ sui --version ``` If the terminal or console responds with a version number, you already have the Sui CLI installed. If the command is not found, follow the instructions in [Install Sui](/getting-started/onboarding/sui-install) to get the Sui CLI on your system. ## Commands ```sh $ sui client --help ``` Client for interacting with the Sui network ```sh Usage: sui client [OPTIONS] [COMMAND] Commands: active-address Default address used for commands when none specified active-env Default environment used for commands when none specified addresses Obtain the Addresses managed by the client balance List the coin balance of an address call Call Move function chain-identifier Query the chain identifier from the rpc endpoint dynamic-field Query a dynamic field by its address envs List all Sui environments execute-signed-tx Execute a Signed Transaction. This is useful when the user prefers to sign elsewhere and use this command to execute execute-combined-signed-tx Execute a combined serialized SenderSignedData string faucet Request gas coin from faucet. By default, it will use the active address and the active network gas Obtain all gas objects owned by the address. An address' alias can be used instead of the address merge-coin Merge two coin objects into one coin new-address 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 new-env Add new Sui environment object Get object info objects Obtain all objects owned by the address. It also accepts an address by its alias party-transfer Transfer object to party ownership pay Pay coins to recipients following specified amounts, with input coins. Length of recipients must be the same as that of amounts pay-all-sui 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 send-funds Send funds to an address balance using the sui::coin::send_funds API. This sends funds to the recipient's address balance (not as a coin object) pay-sui Pay SUI coins to recipients 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 publish Publish Move modules test-publish Publish a package using ephemeral addresses for dependencies upgrade Upgrade Move modules test-upgrade Arguments related to what to do to a transaction after it has been built serialized-tx Execute, dry-run, dev-inspect or otherwise inspect an already serialized transaction serialized-tx-kind Execute, dry-run, dev-inspect or otherwise inspect an already serialized transaction kind split-coin Split a coin object into multiple coins switch Switch active address and network(e.g., devnet, local rpc server) tx-block Get the effects of executing the given transaction block transfer Transfer object transfer-sui 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 verify-bytecode-meter Run the bytecode verifier on the package verify-source Verify local Move packages against onchain packages, and optionally their dependencies remove-address Remove an existing address by its alias or hexadecimal string replay-transaction Replay a given transaction to view transaction effects (deprecated; use `sui replay` instead) replay-batch Replay transactions listed in a file (deprecated; use `sui replay` instead) replay-checkpoint Replay all transactions in a range of checkpoints (deprecated; use `sui replay` instead) help Print this message or the help of the given subcommand(s) Options: --client.config Sets the file storing the state of our user accounts (an empty one will be created if missing) --client.env The Sui environment to use. This must be present in the current config file -y, --yes Create a new sui config without prompting if none exists -q, --quiet Display less output --json Return command outputs in json format -h, --help Print help -V, --version Print version ``` ## JSON output Append the `--json` flag to commands to format responses in JSON instead of the more human-friendly default Sui CLI output. This can be useful for extremely large datasets, for example, as those results can have a troublesome display on smaller screens. In these cases, the `--json` flag is useful. ## Examples The following examples demonstrate some of the most often used commands. For examples that build transactions, prefer `sui client ptb`; it exposes the underlying programmable transaction block commands directly and avoids confusion from legacy helper commands. ### List available network environments Use the `sui client envs` command to find the network environments set up in the CLI. The information for these environments is also stored in the client.yaml file in the Sui configuration directory (`~/.sui/sui_config`). ```sh ╭────────┬────────────────────────────────────┬────────╮ │ alias │ url │ active │ ├────────┼────────────────────────────────────┼────────┤ │ devnet │ https://fullnode.devnet.sui.io:443 │ * │ ╰────────┴────────────────────────────────────┴────────╯ ``` ### Create network environment Use `client new-env` to add details for a new network environment. This example creates an environment pointer to Sui Mainnet. Setting the `alias` value makes referencing the environment less prone to typographical errors. After running this command, Sui updates your client.yaml file in `~/.sui/sui_config` with the new information. ``` $ sui client new-env --alias=mainnet --rpc https://fullnode.mainnet.sui.io:443 Added new Sui env [mainnet] to config. ``` ### Set current environment Use the `sui client switch` command to change the current network. This example switches the current network to `mainnet`. ```sh $ sui client switch --env mainnet ``` ```sh Active environment switched to [mainnet] ``` If you run `sui client envs` after this command, you see the asterisk in the `active` column on the `mainnet` row of the table. ### Get current active address Use the `sui client active-address` command to reveal the current address. The CLI uses the current active address to execute address-specific CLI commands (like `sui client objects`) when you don't provide them with a Sui address value. ```sh $ sui client active-address ``` ```sh 0x514692f08249c3e9951234ce29074695840422564bff85e424b56de462913e0d ``` ### Request a SUI coin from faucet If you use one of the standard public RPCs (for example, `fullnode.devnet.sui.io:443`), you can use the `faucet` command to request gas coins. If you use a custom faucet service, then pass in the URL to the faucet using the `--url` option. The `faucet` command works for a local network, as well. If you start your network with a custom faucet port, include the `--url` option. ```sh $ sui client faucet ``` ```sh Request successful. It can take up to 1 minute to get the coin. Run sui client gas to check your gas coins. ``` ### Get objects owned by an address Use `sui client objects` to list summary information about the objects the current active address owns. You can provide a Sui address value to the command to list objects for a particular address. This example lists objects for the current active address. ```sh $ sui client objects 0x36df11369cf00ecf0be68d6ba965b0abe2e883bc5245911e3a29ebfa0aaf6b69 ``` ```sh ╭───────────────────────────────────────────────────────────────────────────────────────╮ | ╭────────────┬──────────────────────────────────────────────────────────────────────╮ │ │ │ objectId │ 0xfffbb30ccb631f15f6cd36700589fc9c31cb04af28a95f3ed26d62daf3acb57f │ │ │ │ version │ 33363559 │ │ │ │ digest │ IY7/qsIJhliQL0uxwSzNYu0SMcn5AMsqQklSGngn1V0= │ │ │ │ objectType │ 0x0000..0002::coin::Coin │ │ │ ╰────────────┴──────────────────────────────────────────────────────────────────────╯ │ │ ╭────────────┬──────────────────────────────────────────────────────────────────────╮ │ │ │ objectId │ 0xfffe59fb6f78b1ced7f6537e69a205cc45d105270857bfd66332f9a627a38ae0 │ │ │ │ version │ 33370864 │ │ │ │ digest │ b+tKChvujbCk/UCm8L+lflyb6Vjt7beB+uz6+ahUHmM= │ │ │ │ objectType │ 0x0000..0002::coin::Coin │ │ │ ╰────────────┴──────────────────────────────────────────────────────────────────────╯ │ ╰───────────────────────────────────────────────────────────────────────────────────────╯ ``` ### Get complete object information Use `sui client object ` to list object information for the ID you provide. This example displays the information for a Coin object. ```sh $ sui client object 0xfffbb30ccb631f15f6cd36700589fc9c31cb04af28a95f3ed26d62daf3acb57f ``` ```sh ╭───────────────┬─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │ objectId │ 0xfffbb30ccb631f15f6cd36700589fc9c31cb04af28a95f3ed26d62daf3acb57f │ │ version │ 33363559 │ │ digest │ 3FzvXJVVVcXb9H6dEXdARaY9EmxXyyNFduet3X4eYV4x │ │ objType │ 0x2::coin::Coin<0x2::sui::SUI> │ │ ownerType │ AddressOwner │ │ prevTx │ ES2RQThjRE5u8rwiUEnhcnMoLA3cHeEGYJ8Pq98tmyAc │ │ storageRebate │ 988000 │ │ content │ ╭───────────────────┬─────────────────────────────────────────────────────────────────────────────────────────────╮ │ │ │ │ dataType │ moveObject │ │ │ │ │ type │ 0x2::coin::Coin<0x2::sui::SUI> │ │ │ │ │ hasPublicTransfer │ true │ │ │ │ │ fields │ ╭─────────┬───────────────────────────────────────────────────────────────────────────────╮ │ │ │ │ │ │ │ balance │ 530076676 │ │ │ │ │ │ │ │ id │ ╭────┬──────────────────────────────────────────────────────────────────────╮ │ │ │ │ │ │ │ │ │ │ id │ 0xfffbb30ccb631f15f6cd36700589fc9c31cb04af28a95f3ed26d62daf3acb57f │ │ │ │ │ │ │ │ │ │ ╰────┴──────────────────────────────────────────────────────────────────────╯ │ │ │ │ │ │ │ ╰─────────┴───────────────────────────────────────────────────────────────────────────────╯ │ │ │ │ ╰───────────────────┴─────────────────────────────────────────────────────────────────────────────────────────────╯ │ ╰───────────────┴─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ ``` ### Get dynamic fields of an object Use the `sui client dynamic-field ` command to list the details of the dynamic field with the ID you provide. ```sh $ sui client dynamic-field 0x5 ``` ```sh ╭─────────────┬───────────────────────────────────────────────────────────────────────────────────────────╮ │ hasNextPage │ false │ │ nextCursor │ 0x5b890eaf2abcfa2ab90b77b8e6f3d5d8609586c3e583baf3dccd5af17edf48d1 │ │ data │ ╭───────────────────────────────────────────────────────────────────────────────────────╮ │ │ │ │ ╭────────────┬──────────────────────────────────────────────────────────────────────╮ │ │ │ │ │ │ name │ ╭───────┬───────╮ │ │ │ │ │ │ │ │ │ type │ u64 │ │ │ │ │ │ │ │ │ │ value │ 2 │ │ │ │ │ │ │ │ │ ╰───────┴───────╯ │ │ │ │ │ │ │ bcsName │ LQM2cdzDY3 │ │ │ │ │ │ │ type │ DynamicField │ │ │ │ │ │ │ objectType │ 0x3::sui_system_state_inner::SuiSystemStateInnerV2 │ │ │ │ │ │ │ objectId │ 0x5b890eaf2abcfa2ab90b77b8e6f3d5d8609586c3e583baf3dccd5af17edf48d1 │ │ │ │ │ │ │ version │ 112 │ │ │ │ │ │ │ digest │ HMrm1KNKjq3GfB1cWTRdvRo8gk7auhgvoZXaVoyEHqUR │ │ │ │ │ │ ╰────────────┴──────────────────────────────────────────────────────────────────────╯ │ │ │ │ ╰───────────────────────────────────────────────────────────────────────────────────────╯ │ ╰─────────────┴───────────────────────────────────────────────────────────────────────────────────────────╯ ``` :::info The version number in `objectType` (for example, `SuiSystemStateInnerV2`) reflects the protocol version active at the time of the query and may differ depending on the current epoch or network upgrade state. ::: ### Send SUI or objects Use `sui client ptb` to transfer SUI or objects from one address to another. The PTB CLI exposes the same operations used by SDK transaction builders, such as `--split-coins`, `--merge-coins`, and `--transfer-objects`. Assume you have two addresses: ```sh ╭───────────────────┬────────────────────────────────────────────────────────────────────┬────────────────╮ │ alias │ address │ active address │ ├───────────────────┼────────────────────────────────────────────────────────────────────┼────────────────┤ │ hungry-spodumene │ 0x0fe375fff0ee40d20c54a7f2478b9b5c7eaa3625b7611f9661ec5faefb4a6fea │ * │ │ eloquent-amber │ 0x3d78abc33ccd173c521b4f9e78b21ea2c989960b631732c539efaa38bda30976 │ │ ╰───────────────────┴────────────────────────────────────────────────────────────────────┴────────────────╯ ``` To send 0.5 SUI to `eloquent-amber`, split 500,000,000 MIST from the gas coin and transfer the resulting coin in the same PTB: :::tip Beginning with the Sui `v1.24.1` [release](https://github.com/MystenLabs/sui/releases/tag/mainnet-v1.24.1), the `--gas-budget` option is no longer required for CLI commands. ::: ```sh $ sui client ptb \ --split-coins gas "[500000000]" \ --assign coin \ --transfer-objects "[coin]" eloquent-amber \ --gas-budget 5000000 ``` To transfer the full gas coin balance to `eloquent-amber`, transfer `gas` directly. `transfer-objects` is the only PTB command that can take the gas coin by value: ```sh $ sui client ptb \ --transfer-objects "[gas]" eloquent-amber \ --gas-budget 5000000 ``` To transfer another object, pass its object ID with an `@` prefix: ```sh $ sui client ptb \ --transfer-objects "[@]" eloquent-amber \ --gas-budget 5000000 ``` Use `--preview` to inspect the PTB without executing it, or `--dry-run` to simulate execution. See [Sui Client PTB CLI](/references/cli/ptb) for more PTB examples. ### Send funds to an address balance Use `sui client send-funds` to send funds to a recipient's [address balance](/onchain-finance/asset-custody/address-balances/using-address-balances) (using the `sui::coin::send_funds` API) rather than transferring a coin object. The recipient's balance increases without creating a new coin object, and deposits from multiple senders merge into a single balance per coin type. Send 0.5 SUI (500,000,000 MIST) to a recipient: ```sh $ sui client send-funds --to eloquent-amber --amount 500000000 ``` Send a non-SUI coin type: ```sh $ sui client send-funds \ --to eloquent-amber \ --amount 1000000 \ --coin-type 0x::my_coin::MY_COIN ``` The most common options are: - `--to`: Recipient address (or its keystore alias). Required. - `--amount`: Amount to send in the coin's smallest unit (MIST for SUI). Required unless `--all-coins` is set. - `--coin-type`: Coin type to send. Defaults to `0x2::sui::SUI`. - `--all-coins`: Send all owned coin objects of the specified type (not address-balance funds). Conflicts with `--amount` and `--stateless`. - `--stateless`: Draw all funds (including gas) from the sender's address balances, producing a transaction with no owned-object inputs. Conflicts with `--all-coins`. ### Transfer an object to party ownership Use `sui client party-transfer` to transfer a single object to a recipient as a [party-owned](/develop/objects/object-ownership/party) object: ```sh $ sui client party-transfer \ --to eloquent-amber \ --object-id 0x ``` ### Publish and upgrade ephemeral packages `sui client test-publish` and `sui client test-upgrade` publish and upgrade packages without recording the published addresses in the package's `Published.toml`. They build the package for a given environment and publish it on the current network, taking dependency addresses from an ephemeral publication file (the pubfile) and recording the new publication information back into that pubfile. This is useful for testing a package against the live network without mutating your canonical publication state. For background, see [Move Package Management](/develop/manage-packages/move-package-management). Publish a package ephemerally, building for the `testnet` environment and recording publication info in a pubfile: ```sh $ sui client test-publish --pubfile-path Pub.testnet.toml --build-env testnet ``` Later, upgrade that same ephemeral package using the pubfile produced by `test-publish`: ```sh $ sui client test-upgrade --pubfile-path Pub.testnet.toml --build-env testnet ``` The key options are: - `--pubfile-path`: Path to the ephemeral publication file. If omitted, defaults to `Pub..toml` based on the active Sui environment alias. - `--build-env`, `-e`: Environment to build the package for. These commands do not write to `Published.toml`. Use `sui client publish` and `sui client upgrade` for normal, persistent publication. ### Execute a serialized transaction Several commands that build a transaction accept `--serialize-unsigned-transaction` (to output base64 `TransactionData`) and `--serialize-signed-transaction` (to output base64 `SenderSignedData`). The `serialized-tx` and `execute-combined-signed-tx` commands consume those outputs. This is useful for [offline signing](/develop/transactions/transaction-auth/offline-signing) and multisig flows where the build, sign, and execute steps happen separately. Use `sui client serialized-tx` to dry-run, dev-inspect, or execute an already serialized `TransactionData` (base64-encoded BCS). The sender, gas payment, and gas budget are read from the serialized data: ```sh # Inspect without executing $ sui client serialized-tx --dry-run # Execute the serialized transaction $ sui client serialized-tx ``` A related command, `sui client serialized-tx-kind`, takes a serialized `TransactionKind` instead and lets you supply gas payment and budget separately with `--gas` and `--gas-budget`. Use `sui client execute-combined-signed-tx` to execute a combined `SenderSignedData` blob (transaction data plus its signatures). This is the output produced by passing `--serialize-signed-transaction` to a transaction-building command: ```sh $ sui client execute-combined-signed-tx --signed-tx-bytes ``` To execute a transaction whose data and signatures were produced separately (for example, signed with `sui keytool sign`), use `sui client execute-signed-tx --tx-bytes --signatures ` instead. ### Replay a transaction Client commands to replay transactions have been deprecated in favor of the `sui replay` command. Learn about replaying a transaction and how it can be used for debugging or profiling in the [Transaction Replay](/references/cli/replay), [Debugging Transactions](/references/ide/debugger), and [Transaction Trace Analysis](/references/cli/trace-analysis) guides. ## Publish a Move package One of the main uses of the `sui client` command is to publish smart contracts on the Sui network. This example switches the current environment to Devnet, then builds, tests, and publishes one of the existing Move examples available in the Sui repository: [sui/examples/move](https://github.com/MystenLabs/sui/tree/main/examples/move) This example also makes use of `sui move` commands. To learn more about those commands, see [Sui Move CLI](/references/cli/move). 1. Open a terminal or console to the root of your local Sui repository and navigate to the `move_tutorial` example. ```sh $ cd examples/move/first_package ``` 1. Switch to Devnet network. This command uses an alias, so the `devnet` value might be different for you, depending on the alias name set in your configuration (use `sui client envs` for a list of your defined networks and their aliases). ```sh $ sui client switch --env devnet ``` 1. Use `sui move build` to build the package. You must run this command at the same level as the package manifest file ([Move.toml](/develop/manage-packages/move-package-management)). ```sh $ sui move build ``` The console responds with the status of the build. ```sh INCLUDING DEPENDENCY Sui INCLUDING DEPENDENCY MoveStdlib BUILDING first_package ``` 1. Use `sui move test` to run the unit tests. ```sh $ sui move test ``` The console responds with updates of its progress. ```sh INCLUDING DEPENDENCY Sui INCLUDING DEPENDENCY MoveStdlib BUILDING first_package Running Move unit tests [ PASS ] 0x0::example::test_module_init [ PASS ] 0x0::example::test_sword_transactions Test result: OK. Total tests: 2; passed: 2; failed: 0 ``` 1. Use the `sui client verify-bytecode-meter` to check if the module passes the bytecode meter. ```sh $ sui client verify-bytecode-meter ``` The console responds with the maximum allowed values, as well as the amount the package uses. ```sh Running bytecode verifier for 1 modules ╭──────────────────────────────────╮ │ Module passes metering check. │ ├────────┬────────────┬────────────┤ │ │ Module │ Function │ │ Max │ 16000000 │ 16000000 │ │ Used │ 4565 │ 4565 │ ╰────────┴────────────┴────────────╯ ``` 1. Use `sui client gas` to verify that the active address has a gas coin for paying gas. ```sh $ sui client gas ``` In the case of this example, the console responds with the information that the address is coinless. ```sh No gas coins are owned by this address ``` 1. If you need coins, use `sui client faucet` (not available for Mainnet). For more information on getting gas tokens, see [Get Sui Tokens](/getting-started/onboarding/get-coins). ```sh $ sui client faucet ``` 1. Use `sui client gas` to verify the current active address received the coins. ```sh $ sui client gas ``` ```sh ╭────────────────────────────────────────────────────────────────────┬─────────────╮ │ gasCoinId │ gasBalance │ ├────────────────────────────────────────────────────────────────────┼─────────────┤ │ 0x01b2795ba5800c8f7cb7d7c56abe19e24c656ed6764f3ccc5e66da3de52402a8 │ 10000000000 │ ╰────────────────────────────────────────────────────────────────────┴─────────────╯ ``` 1. Use `sui client publish` to publish the package, being sure to set an appropriate value for the `gas-budget` flag if you're using an older version of Sui. The console responds with the details of the publish. You can use `sui client object ` to check the details of any of the objects from the process. ```sh $ sui client publish --gas-budget 100000000 . ``` ```sh Transaction Digest: ABPd7v8BxLkcyHvX8Jt1SbneQRwzE9WzcEoptT2RDNVF ╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │ Transaction Data │ ├──────────────────────────────────────────────────────────────────────────────────────────────────────────────┤ │ Sender: 0x0fe375fff0ee40d20c54a7f2478b9b5c7eaa3625b7611f9661ec5faefb4a6fea │ │ Gas Owner: 0x0fe375fff0ee40d20c54a7f2478b9b5c7eaa3625b7611f9661ec5faefb4a6fea │ │ Gas Budget: 5000000000 MIST │ │ Gas Price: 1000 MIST │ │ Gas Payment: │ │ ┌── │ │ │ ID: 0x01b2795ba5800c8f7cb7d7c56abe19e24c656ed6764f3ccc5e66da3de52402a8 │ │ │ Version: 2 │ │ │ Digest: GZQwvpxLeTciVboEWeC8EZ2KYYU9o6XoBtW6LrA5Si1h │ │ └── │ │ │ │ Transaction Kind: Programmable │ │ ╭──────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │ │ │ Input Objects │ │ │ ├──────────────────────────────────────────────────────────────────────────────────────────────────────────┤ │ │ │ 0 Pure Arg: Type: address, Value: "0x0fe375fff0ee40d20c54a7f2478b9b5c7eaa3625b7611f9661ec5faefb4a6fea" │ │ │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────╯ │ │ ╭─────────────────────────────────────────────────────────────────────────╮ │ │ │ Commands │ │ │ ├─────────────────────────────────────────────────────────────────────────┤ │ │ │ 0 Publish: │ │ │ │ ┌ │ │ │ │ │ Dependencies: │ │ │ │ │ 0x0000000000000000000000000000000000000000000000000000000000000001 │ │ │ │ │ 0x0000000000000000000000000000000000000000000000000000000000000002 │ │ │ │ └ │ │ │ │ │ │ │ │ 1 TransferObjects: │ │ │ │ ┌ │ │ │ │ │ Arguments: │ │ │ │ │ Result 0 │ │ │ │ │ Address: Input 0 │ │ │ │ └ │ │ │ ╰─────────────────────────────────────────────────────────────────────────╯ │ │ │ │ Signatures: │ │ x437h/JxDAba2zkx4a2kEfz6iaXQ08T7+inyP5YkbmlSB5K7IYasM6onckjYDB19FNM1ZNqXm1z13VyTmDHXCw== │ │ │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭───────────────────────────────────────────────────────────────────────────────────────────────────╮ │ Transaction Effects │ ├───────────────────────────────────────────────────────────────────────────────────────────────────┤ │ Digest: ABPd7v8BxLkcyHvX8Jt1SbneQRwzE9WzcEoptT2RDNVF │ │ Status: Success │ │ Executed Epoch: 0 │ │ │ │ Created Objects: │ │ ┌── │ │ │ ID: 0x569828cc4e134ccccd7408def18b80af1465ac791fd4ef40483f6b16e2f00d95 │ │ │ Owner: Account Address ( 0x0fe375fff0ee40d20c54a7f2478b9b5c7eaa3625b7611f9661ec5faefb4a6fea ) │ │ │ Version: 3 │ │ │ Digest: 4iD7ZhsFS9iFuszqxBSEL6xZdcnWG76WGgU4D5PH1PeL │ │ └── │ │ ┌── │ │ │ ID: 0xde670ae990c8f20fd53e9f597a0da056bdb634175176602658e9da2c2ec9cb93 │ │ │ Owner: Account Address ( 0x0fe375fff0ee40d20c54a7f2478b9b5c7eaa3625b7611f9661ec5faefb4a6fea ) │ │ │ Version: 3 │ │ │ Digest: AV27tn7ePXhdDyDV9TCkSQZA3mkMei9DV63AmB4DEjGN │ │ └── │ │ ┌── │ │ │ ID: 0xe1d9d66b7a19b27ebda338a52593cd10e728f666f34ecd30a7cc2ad3fed186da │ │ │ Owner: Immutable │ │ │ Version: 1 │ │ │ Digest: 4bzxMQgcSZoKzppNiRtQwAWDBvCgjr18gQi2H8Yk1tQZ │ │ └── │ │ Mutated Objects: │ │ ┌── │ │ │ ID: 0x01b2795ba5800c8f7cb7d7c56abe19e24c656ed6764f3ccc5e66da3de52402a8 │ │ │ Owner: Account Address ( 0x0fe375fff0ee40d20c54a7f2478b9b5c7eaa3625b7611f9661ec5faefb4a6fea ) │ │ │ Version: 3 │ │ │ Digest: 46rvdbXkw5qqsBYbUGChzgFatJAYPmarPmFHgRRJiiU9 │ │ └── │ │ Gas Object: │ │ ┌── │ │ │ ID: 0x01b2795ba5800c8f7cb7d7c56abe19e24c656ed6764f3ccc5e66da3de52402a8 │ │ │ Owner: Account Address ( 0x0fe375fff0ee40d20c54a7f2478b9b5c7eaa3625b7611f9661ec5faefb4a6fea ) │ │ │ Version: 3 │ │ │ Digest: 46rvdbXkw5qqsBYbUGChzgFatJAYPmarPmFHgRRJiiU9 │ │ └── │ │ Gas Cost Summary: │ │ Storage Cost: 9978800 │ │ Computation Cost: 1000000 │ │ Storage Rebate: 978120 │ │ Non-refundable Storage Fee: 9880 │ │ │ │ Transaction Dependencies: │ │ 891Qjq6qDZ6SzAJiAg3CEaHobXrpDL5bAy2o45ZJPTuB │ │ ESHcS3y3VCuaCVmWkKDx3EXX3icfPtj4bHhk86gaGWdo │ ╰───────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─────────────────────────────╮ │ No transaction block events │ ╰─────────────────────────────╯ ╭────────────────────────────────────────────────────────────────────────────────────────────────────╮ │ Object Changes │ ├────────────────────────────────────────────────────────────────────────────────────────────────────┤ │ Created Objects: │ │ ┌── │ │ │ ObjectID: 0x569828cc4e134ccccd7408def18b80af1465ac791fd4ef40483f6b16e2f00d95 │ │ │ Sender: 0x0fe375fff0ee40d20c54a7f2478b9b5c7eaa3625b7611f9661ec5faefb4a6fea │ │ │ Owner: Account Address ( 0x0fe375fff0ee40d20c54a7f2478b9b5c7eaa3625b7611f9661ec5faefb4a6fea ) │ │ │ ObjectType: 0xe1d9d66b7a19b27ebda338a52593cd10e728f666f34ecd30a7cc2ad3fed186da::example::Forge │ │ │ Version: 3 │ │ │ Digest: 4iD7ZhsFS9iFuszqxBSEL6xZdcnWG76WGgU4D5PH1PeL │ │ └── │ │ ┌── │ │ │ ObjectID: 0xde670ae990c8f20fd53e9f597a0da056bdb634175176602658e9da2c2ec9cb93 │ │ │ Sender: 0x0fe375fff0ee40d20c54a7f2478b9b5c7eaa3625b7611f9661ec5faefb4a6fea │ │ │ Owner: Account Address ( 0x0fe375fff0ee40d20c54a7f2478b9b5c7eaa3625b7611f9661ec5faefb4a6fea ) │ │ │ ObjectType: 0x2::package::UpgradeCap │ │ │ Version: 3 │ │ │ Digest: AV27tn7ePXhdDyDV9TCkSQZA3mkMei9DV63AmB4DEjGN │ │ └── │ │ Mutated Objects: │ │ ┌── │ │ │ ObjectID: 0x01b2795ba5800c8f7cb7d7c56abe19e24c656ed6764f3ccc5e66da3de52402a8 │ │ │ Sender: 0x0fe375fff0ee40d20c54a7f2478b9b5c7eaa3625b7611f9661ec5faefb4a6fea │ │ │ Owner: Account Address ( 0x0fe375fff0ee40d20c54a7f2478b9b5c7eaa3625b7611f9661ec5faefb4a6fea ) │ │ │ ObjectType: 0x2::coin::Coin<0x2::sui::SUI> │ │ │ Version: 3 │ │ │ Digest: 46rvdbXkw5qqsBYbUGChzgFatJAYPmarPmFHgRRJiiU9 │ │ └── │ │ Published Objects: │ │ ┌── │ │ │ PackageID: 0xe1d9d66b7a19b27ebda338a52593cd10e728f666f34ecd30a7cc2ad3fed186da │ │ │ Version: 1 │ │ │ Digest: 4bzxMQgcSZoKzppNiRtQwAWDBvCgjr18gQi2H8Yk1tQZ │ │ │ Modules: example │ │ └── │ ╰────────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭───────────────────────────────────────────────────────────────────────────────────────────────────╮ │ Balance Changes │ ├───────────────────────────────────────────────────────────────────────────────────────────────────┤ │ ┌── │ │ │ Owner: Account Address ( 0x0fe375fff0ee40d20c54a7f2478b9b5c7eaa3625b7611f9661ec5faefb4a6fea ) │ │ │ CoinType: 0x2::sui::SUI │ │ │ Amount: -10000680 │ │ └── │ ╰───────────────────────────────────────────────────────────────────────────────────────────────────╯ ``` ## Help Each command has its own help section. For example: ```sh $ sui client call --help ``` ```sh Call Move function Usage: sui client call [OPTIONS] --package --module --function Options: --package Object ID of the package, which contains the module --module The name of the module in the package --function Function name in module --type-args ... Type arguments to the generic function being called. All must be specified, or the call will fail --args ... Simplified ordered args like in the function syntax ObjectIDs, Addresses must be hex strings --gas ... IDs of gas objects to be used for gas payment. If none are provided, coins are selected automatically to cover the gas budget --gas-budget An optional gas budget for this transaction (in MIST). If gas budget is not provided, the tool will first perform a dry run to estimate the gas cost, and then it will execute the transaction. Please note that this incurs a small cost in performance due to the additional dry run call --gas-price An optional gas price for this transaction (in MIST). If gas price is not provided, the tool will use the current reference gas price from RPC. Transactions with a gas price lower than the reference will not be signed by enough validators to execute. Transactions accessing congested shared objects are prioritized by gas price, so setting a higher gas price higher than the reference can ensure the transaction accesses the shared object sooner. --gas-sponsor An optional field to specify a gas sponsor address. If provided, the gas owner is set to this address, rather than the transaction's sender. Note that if the CLI does not have access to the sponsor's keys, it will not be able to sign and execute transactions that have a sponsor set. --tx-digest Compute the transaction digest and print it out, but do not execute the transaction --dry-run Perform a dry run of the transaction, without executing it --dev-inspect Perform a dev inspect --serialize-unsigned-transaction Instead of executing the transaction, serialize the bcs bytes of the unsigned transaction data (TransactionData) using base64 encoding, and print out the string . The string can be used to execute transaction with `sui client execute-signed-tx --tx-bytes ` --serialize-signed-transaction Instead of executing the transaction, serialize the bcs bytes of the signed transaction data (SenderSignedData) using base64 encoding, and print out the string . The string can be used to execute transaction with `sui client execute-combined-signed-tx --signed-tx-bytes ` --sender Set the transaction sender to this address. When not specified, the sender is inferred by finding the owner of the gas payment. Note that when setting this field, the transaction will fail to execute if the sender's private key is not in the keystore; similarly, it will fail when using this with `--serialize-signed-transaction` flag if the private key corresponding to this address is not in keystore -q, --quiet Display less output --json Return command outputs in json format -h, --help Print help (see a summary with '-h') -V, --version Print version ```