From 50c085a5a0b40eccb2cfb6c44aba72ce0000c495 Mon Sep 17 00:00:00 2001 From: ronny-mysten <118224482+ronny-mysten@users.noreply.github.com> Date: Fri, 3 Jan 2025 09:02:05 -0700 Subject: [PATCH] [docs] Updates the multisig guide (#20762) ## Description Updates the multisig guide topic. ## Test plan Local --- ## Release notes Check each box that your changes affect. If none of the boxes relate to your changes, release notes aren't required. For each box you select, include information after the relevant heading that describes the impact of your changes that a user might notice and any actions they must take to implement updates. - [ ] Protocol: - [ ] Nodes (Validators and Full nodes): - [ ] gRPC: - [ ] JSON-RPC: - [ ] GraphQL: - [ ] CLI: - [ ] Rust SDK: --- .../developer/cryptography/multisig.mdx | 435 ++++++++++++++---- 1 file changed, 339 insertions(+), 96 deletions(-) diff --git a/docs/content/guides/developer/cryptography/multisig.mdx b/docs/content/guides/developer/cryptography/multisig.mdx index 03c647cec31bd..f9547bfc3a869 100644 --- a/docs/content/guides/developer/cryptography/multisig.mdx +++ b/docs/content/guides/developer/cryptography/multisig.mdx @@ -3,156 +3,399 @@ title: Multisig Authentication description: Guide on how to create a multisig transaction and then submit it against a local network using the Sui CLI. --- -The following steps demonstrate how to create a multisig transaction and then submit it against a local network using the [Sui CLI](/references/cli.mdx). A transaction can be the transfer of an object, the publish or upgrade of a package, the payment of SUI, and so on. To learn how to set up a local network, see [Connect to a Local Network](/guides/developer/getting-started/local-network.mdx). +The following steps demonstrate how to create a multisig transaction and then submit it against a network using the [Sui CLI](/references/cli.mdx). A transaction can be the transfer of an object, the publish or upgrade of a package, the payment of SUI, and so on. -To learn more about how to create multisig addresses and create multisig transactions using the TypeScript SDK, see the [SDK documentation](https://sdk.mystenlabs.com/typescript/cryptography/multisig) for details. +To learn more about how to create multisig addresses and create multisig transactions using the TypeScript SDK, see the [SDK documentation](https://sdk.mystenlabs.com/typescript/cryptography/multisig) for details. -## Step 1: Create keys +## Prerequisites -Use the following command to generate a Sui address and key for each supported key scheme and add it to the `sui.keystore`, then list the keys. +This topic assumes you are somewhat familiar with the Sui CLI, specifically the `sui client` and `sui keytool` commands. Consequently, a command might be introduced without any context. If you are unsure about the details of a referenced command, see the Sui CLI documentation for more information. -Use `sui client` to create Sui addresses of different key schemes. +You need an existing address on the network you are working on to receive an object. The topic assumes that this address is the current active address (`sui client active-address`), but any address you have access to is fine. -```shell -sui client new-address ed25519 -sui client new-address secp256k1 -sui client new-address secp256r1 +The topic also assumes that your active environment is Testnet (`sui client active-env`). You can perform these steps on Devnet or a local network as well, but you must adjust the instructions appropriately. + +## Executing multisig transactions + +To demonstrate multisig, this topic guides you through setting up and executing a multisig transaction using the Sui CLI. + +### Create addresses with different schemes + +To begin, create three addresses that will act as the signers for the transaction you perform later in the instruction. Use the `sui client new-address` command to generate a Sui address and public key for three supported key schemes. + +```sh +$ sui client new-address ed25519 +``` +```sh +$ sui client new-address secp256k1 +``` +```sh +$ sui client new-address secp256r1 ``` -## Step 2: Add keys to Sui keystore +The console displays a response to each successful call that is similar to the following: + +```sh +╭──────────────────────────────────────────────────╮ +│ Created new keypair and saved it to keystore. │ +├────────────────┬─────────────────────────────────┤ +│ alias │ │ +│ address │ │ +│ keyScheme │ │ +│ recoveryPhrase │ │ +╰────────────────┴─────────────────────────────────╯ +``` -Use `sui keytool` to list the signatures you created in the previous step. +When working with blockchain data, addresses and hashed values create large strings that can be cumbersome to work with in a CLI environment. To make referencing values easier in subsequent commands (and facilitate copy and paste), this topic uses shell variables. Use the values you receive from the console responses to set shell variables for these addresses, replacing the `` variables with the appropriate address. -```shell -sui keytool list +```sh +$ ADDRESS1= +``` +```sh +$ ADDRESS2= +``` +```sh +$ ADDRESS3= +``` + +Create one more shell variable assigned to your active address. + +```sh +$ ACTIVE= ``` -The response resembles the following, but displays actual addresses, keys, and peer IDs: +:::tip + +You can set the shell variables to the alias values instead of addresses if you want. + +::: + +### Verify addresses + +Use `sui keytool` to list the addresses you created in the previous section. ```shell -╭────────────────────────────────────────────────────────────────────────────────────────────╮ -│ ╭─────────────────┬──────────────────────────────────────────────────────────────────────╮ │ -│ │ suiAddress │ │ │ -│ │ publicBase64Key │ │ │ -│ │ keyScheme │ ed25519 │ │ -│ │ flag │ 0 │ │ -│ │ peerId │ │ │ -│ ╰─────────────────┴──────────────────────────────────────────────────────────────────────╯ │ -│ ╭─────────────────┬──────────────────────────────────────────────────────────────────────╮ │ -│ │ suiAddress │ │ │ -│ │ publicBase64Key │ │ │ -│ │ keyScheme │ secp256k1 │ │ -│ │ flag │ 0 │ │ -│ │ peerId │ │ │ -│ ╰─────────────────┴──────────────────────────────────────────────────────────────────────╯ │ -│ ╭─────────────────┬──────────────────────────────────────────────────────────────────────╮ │ -│ │ suiAddress │ │ │ -│ │ publicBase64Key │ │ │ -│ │ keyScheme │ secp256r1 │ │ -│ │ flag │ 0 │ │ -│ │ peerId │ │ │ -│ ╰─────────────────┴──────────────────────────────────────────────────────────────────────╯ │ -╰────────────────────────────────────────────────────────────────────────────────────────────╯ -``` - -## Step 3: Create a multisig address - -To create a multisig address, input a list of public keys to use for the multisig address and a list of their corresponding weights and the threshold (replacing `` with actual values). +$ sui keytool list +``` + +The response resembles the following, but displays actual alias names, addresses, keys, and peer IDs: ```shell -sui keytool multi-sig-address --pks --weights 1 2 3 --threshold 3 +╭────────────────────────────────────────────────────────────────────╮ +│ ╭─────────────────┬──────────────────────────────────────────────╮ │ +| | alias | | | +│ │ suiAddress │ │ │ +│ │ publicBase64Key │ │ │ +│ │ keyScheme │ ed25519 │ │ +│ │ flag │ 0 │ │ +│ │ peerId │ │ │ +│ ╰─────────────────┴──────────────────────────────────────────────╯ │ +│ ╭─────────────────┬──────────────────────────────────────────────╮ │ +| | alias | | | +│ │ suiAddress │ │ │ +│ │ publicBase64Key │ │ │ +│ │ keyScheme │ secp256k1 │ │ +│ │ flag │ 0 │ │ +│ │ peerId │ │ │ +│ ╰─────────────────┴──────────────────────────────────────────────╯ │ +│ ╭─────────────────┬──────────────────────────────────────────────╮ │ +| | alias | | | +│ │ suiAddress │ │ │ +│ │ publicBase64Key │ │ │ +│ │ keyScheme │ secp256r1 │ │ +│ │ flag │ 0 │ │ +│ │ peerId │ │ │ +│ ╰─────────────────┴──────────────────────────────────────────────╯ │ +╰────────────────────────────────────────────────────────────────────╯ ``` -The response resembles the following: +The output includes public key data that you use later, so create shell variables to store the information. Don't forget to replace `` with the actual values you receive from the previous console response. +```sh +$ PKEY_1= +``` +```sh +$ PKEY_2= ``` -╭─────────────────┬────────────────────────────────────────────────────────────────────────────────────╮ -│ multisigAddress │ │ -│ multisig │ ╭────────────────────────────────────────────────────────────────────────────────╮ │ -│ │ │ ╭─────────────────┬──────────────────────────────────────────────────────────╮ │ │ -│ │ │ │ address │ │ │ │ -│ │ │ │ publicBase64Key │ │ │ │ -│ │ │ │ weight │ 1 │ │ │ -│ │ │ ╰─────────────────┴──────────────────────────────────────────────────────────╯ │ │ -│ │ │ ╭─────────────────┬──────────────────────────────────────────────────────────╮ │ │ -│ │ │ │ address │ │ │ │ -│ │ │ │ publicBase64Key │ │ │ │ -│ │ │ │ weight │ 2 │ │ │ -│ │ │ ╰─────────────────┴──────────────────────────────────────────────────────────╯ │ │ -│ │ │ ╭─────────────────┬──────────────────────────────────────────────────────────╮ │ │ -│ │ │ │ address │ │ │ │ -│ │ │ │ publicBase64Key │ │ │ │ -│ │ │ │ weight │ 3 │ │ │ -│ │ │ ╰─────────────────┴──────────────────────────────────────────────────────────╯ │ │ -│ │ ╰────────────────────────────────────────────────────────────────────────────────╯ │ -╰─────────────────┴────────────────────────────────────────────────────────────────────────────────────╯ -``` - -## Step 4: Send objects to a multisig address - -This example requests gas from a local network using the default URL following the guidance in [Connect to a Local Network](/guides/developer/getting-started/local-network.mdx). If following along, be sure to replace `` with the address you receive in the previous step. +```sh +$ PKEY_3= +``` + +### Create a multisig address + +To sign a transaction using multisig, you need to create a multisig address using `sui keytool multi-sig-address`. The multisig address is created using the public keys from each individual participating address. Each address is also assigned a `weight` value that determines how many are needed to create a valid signature. When summed, the `weight` of the included signatures must be greater than or equal to the `threshold` value you also set with the command. For this example, use the following command, which states that the first two addresses require at least one more signature to create a valid multisig. The last address has a weight of `3`, which is equal to the `threshold` value, so its owner can create a valid signature without the others. ```shell -curl --location --request POST 'http://127.0.0.1:9123/gas' --header 'Content-Type: application/json' --data-raw "{ \"FixedAmountRequest\": { \"recipient\": \"\" } }" +$ sui keytool multi-sig-address --pks $PKEY_1 $PKEY_2 $PKEY_3 --weights 1 2 3 --threshold 3 ``` The response resembles the following: ``` -{"transferred_gas_objects":[{"amount":200000,"id":"", ...}]} +╭─────────────────┬─────────────────────────────────────────────────────────╮ +│ multisigAddress │ │ +│ multisig │ ╭─────────────────────────────────────────────────────╮ │ +│ │ │ ╭─────────────────┬───────────────────────────────╮ │ │ +│ │ │ │ address │ │ │ │ +│ │ │ │ publicBase64Key │ │ │ │ +│ │ │ │ weight │ 1 │ │ │ +│ │ │ ╰─────────────────┴───────────────────────────────╯ │ │ +│ │ │ ╭─────────────────┬───────────────────────────────╮ │ │ +│ │ │ │ address │ │ │ │ +│ │ │ │ publicBase64Key │ │ │ │ +│ │ │ │ weight │ 2 │ │ │ +│ │ │ ╰─────────────────┴───────────────────────────────╯ │ │ +│ │ │ ╭─────────────────┬───────────────────────────────╮ │ │ +│ │ │ │ address │ │ │ │ +│ │ │ │ publicBase64Key │ │ │ │ +│ │ │ │ weight │ 3 │ │ │ +│ │ │ ╰─────────────────┴───────────────────────────────╯ │ │ +│ │ ╰─────────────────────────────────────────────────────╯ │ +╰─────────────────┴─────────────────────────────────────────────────────────╯ ``` -## Step 5: Serialize any transaction +### Add SUI to the multisig address + +Before getting SUI, set a `MULTISIG` shell variable to the multisig address provided at the top of the previous response (substituting the actual address for ``). -This section demonstrates how to use an object that belongs to a multisig address and serialize a transfer to be signed. The `tx_bytes` value can be any serialized transaction data where the sender is the multisig address. Use the `--serialize-unsigned-transaction` flag for supported commands in `sui client -h` (`publish`, `upgrade`, `call`, `transfer`, `transfer-sui`, `pay`, `pay-all-sui`, `pay-sui`, `split`, `merge-coin`) to output the Base64 encoded transaction bytes. +```sh +$ MULTISIG= +``` + +If you use the `sui client objects $MULTISIG` command, you can see that the newly created multisig address has no objects. This means you need to get SUI before you can perform any transactions. To get SUI for your multisig account, use the `sui client faucet` command and provide the multisig address using the `--address` flag. Run this command twice so that the multisig address owns at least two SUI. This example uses two SUI so that one can be transferred and the other can pay for gas. + +```sh +$ sui client faucet --address $MULTISIG +``` + +Use the `sui client gas` command to verify the address now has at least two SUI. + +```sh +$ sui client gas $MULTISIG +``` + +### Transfer SUI to your active address + +It's now time to transfer an object from the multisig address. For simplicity, this example uses one of the coins your multisig address owns as the transfer object. Copy the object ID for one of the address' coins and use it to set a shell variable value. + +```sh +$ COIN= +``` + +Use the `sui client transfer` command to set up the transfer. The `--serialize-unsigned-transaction` flag outputs the Base64-encoded transaction bytes. {@include: ../../../snippets/info-gas-budget.mdx} -```shell -sui client transfer --to --object-id --gas-budget --serialize-unsigned-transaction +```sh +$ sui client transfer --to $ACTIVE --object-id $COIN --gas-budget --serialize-unsigned-transaction +``` + +The console displays the result (``), which you can assign to another shell variable. -Raw tx_bytes to execute: +```sh +$ TXBYTES= ``` -## Step 6: Sign the transaction with two keys +### Sign the transaction with two public keys -Use the following code sample to sign the transaction with two keys in `sui.keystore`. You can do this with other tools as long as you serialize it to `flag || sig || pk`. +Use the `sui keytool sign` command to sign the transaction using two of the addresses you created previously. + +:::info + +You can create the signature with other tools, as well, as long as you serialize it to `flag || sig || pk`. + +::: ```shell -sui keytool sign --address --data +$ sui keytool sign --address $ADDRESS1 --data $TXBYTES +``` +```sh +$ sui keytool sign --address $ADDRESS2 --data $TXBYTES +``` -Raw tx_bytes to execute: -Serialized signature (`flag || sig || pk` in Base64): $SIG_1 +Each successful call to the command receives a response similar to the following. + +```sh +╭──────────────┬─────────────────────────────╮ +│ suiAddress │
│ +│ rawTxData │ │ +│ intent │ ╭─────────┬─────╮ │ +│ │ │ scope │ 0 │ | +│ │ │ version │ 0 │ | +│ │ │ app_id │ 0 │ | +| | ╰─────────┴─────╯ │ +│ rawIntentMsg │ │ +│ digest │ │ +│ suiSignature │ │ +╰──────────────┴─────────────────────────────╯ +``` -sui keytool sign --address --data +Create two more shell variables to store the signatures, replaceing `` with the values from the previous command responses. -Raw tx_bytes to execute: -Serialized signature (`flag || sig || pk` in Base64): $SIG_2 +```sh +$ SIG_1= +``` +```sh +$ SIG_2= ``` -## Step 7: Combine individual signatures into a multisig +### Combine individual signatures into a multisig -This sample demonstrates how to combine the two signatures: +As mentioned, the multisig must be composed of enough individual signatures such that the sum of the participating signer weights is greater than the `threshold` value. Use the `sui keytool multi-sig-combine-partial-sig` command to combine the ed25519 signature (`weight: 1`) and the secp256k1 (`weight: 2`). To complete the command, you must provide all public keys, their weights, and the threshold that defined the multisig address. ```shell -sui keytool multi-sig-combine-partial-sig --pks --weights 1 2 3 --threshold 3 --sigs +$ sui keytool multi-sig-combine-partial-sig --pks $PKEY_1 $PKEY_2 $PKEY_3 --weights 1 2 3 --threshold 3 --sigs $SIG_1 $SIG_2 +``` + +If successful, the console responds with a message similar to the following. -multisig address: # Informational -multisig parsed: # Informational -multisig serialized: +```sh +╭────────────────────┬──────────────────────────────╮ +│ multisigAddress │ │ +│ multisigParsed │ │ +│ multisigSerialized │ │ +╰────────────────────┴──────────────────────────────╯ ``` -You need only the signatures of the participating signers whose sum of weights `>=k`. You must provide all public keys and their weights, and the threshold that defined the multisig address. +### Execute the transaction + +Use `sui client execute-signed-tx` to execute the multisig transaction. Set a shell variable equal to the `multisigSerialized` value you receive from the previous response, then use it to build the `execute-signed-tx` command. -## Step 8: Execute a transaction with multisig +```sh +$ MULTISIG_SERIALIZED= +``` -Use `sui client` to execute a transaction using multisig: +```sh +$ sui client execute-signed-tx --tx-bytes $TXBYTES --signatures $MULTISIG_SERIALIZED +``` -```shell -sui client execute-signed-tx --tx-bytes --signatures +If successful, the console responds with transaction details. + +
+ +Transaction response + +This response contains the actual values from a test signing. Your response should be formatted the same but the values you receive are going to be different. + +```sh +Transaction Digest: 7mBWUxT6HUVDa8bii3PZJc7nhWqefTLNTsGbHYnx7ZA4 +╭─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ +│ Transaction Data │ +├─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤ +│ Sender: 0xfc9a64c928a09725cfe01478ad50c2418320b4c079d944ed430eff0f30666a35 │ +│ Gas Owner: 0xfc9a64c928a09725cfe01478ad50c2418320b4c079d944ed430eff0f30666a35 │ +│ Gas Budget: 2997880 MIST │ +│ Gas Price: 1000 MIST │ +│ Gas Payment: │ +│ ┌── │ +│ │ ID: 0xc62a5e163e599729509d6cebde097cac04e5d1b3bbc9a169144e8dfa602a0768 │ +│ │ Version: 289574879 │ +│ │ Digest: 2PMc8L67YbZmna4hoaryX9cZZFSgFNPEYPEeCqcDPCcX │ +│ └── │ +│ │ +│ Transaction Kind: Programmable │ +│ ╭──────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │ +│ │ Input Objects │ │ +│ ├──────────────────────────────────────────────────────────────────────────────────────────────────────────┤ │ +│ │ 0 Pure Arg: Type: address, Value: "0x65437300e280695a40df8cf524c7bca6ad62574cac3a52d3b085ad628c797241" │ │ +│ │ 1 Imm/Owned Object ID: 0xe7acb59c190d7fcfcb622916e929c92007f6da15128fd84c8a2afd94a39edf11 │ │ +│ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────╯ │ +│ ╭──────────────────────╮ │ +│ │ Commands │ │ +│ ├──────────────────────┤ │ +│ │ 0 TransferObjects: │ │ +│ │ ┌ │ │ +│ │ │ Arguments: │ │ +│ │ │ Input 1 │ │ +│ │ │ Address: Input 0 │ │ +│ │ └ │ │ +│ ╰──────────────────────╯ │ +│ │ +│ Signatures: │ +│ AwICIrr3sYG1hx2DaVkS3levGuTv68GA1RL+6ZFbtnFV5PBPkEHuysjme9nG0hZ3hQ0eDds2CedbKkLqDyCUXMNQDwEUtr9SYWRGiJJih21cAXgpSxf5Y53HFcmzJPWfxac54l21YVx6hc7vhI1xunMzhVeQlCa53vVJiAtWKLKz+H7FBgADAPZrm85y/Gn83R6kUhXme9J8W2ilJyda6cAObtuyJ3CqAQICAwSWHr3Q2vGVFH4SQckaQs76X89S6hX3NUarydSY3jgCAQNqj1MFWmTysOPFDXdNfD2kJlQhWTiT3AbxdlJDDWozIgMDAA== │ +│ │ +╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ +╭───────────────────────────────────────────────────────────────────────────────────────────────────╮ +│ Transaction Effects │ +├───────────────────────────────────────────────────────────────────────────────────────────────────┤ +│ Digest: 7mBWUxT6HUVDa8bii3PZJc7nhWqefTLNTsGbHYnx7ZA4 │ +│ Status: Success │ +│ Executed Epoch: 600 │ +│ Mutated Objects: │ +│ ┌── │ +│ │ ID: 0xc62a5e163e599729509d6cebde097cac04e5d1b3bbc9a169144e8dfa602a0768 │ +│ │ Owner: Account Address ( 0xfc9a64c928a09725cfe01478ad50c2418320b4c079d944ed430eff0f30666a35 ) │ +│ │ Version: 289574880 │ +│ │ Digest: DWmLziJZEHwhkAfdBWVhn8HnJU7DMepDmjVLps2peSx8 │ +│ └── │ +│ ┌── │ +│ │ ID: 0xe7acb59c190d7fcfcb622916e929c92007f6da15128fd84c8a2afd94a39edf11 │ +│ │ Owner: Account Address ( 0x65437300e280695a40df8cf524c7bca6ad62574cac3a52d3b085ad628c797241 ) │ +│ │ Version: 289574880 │ +│ │ Digest: JBA6PrhWuTUJ3P8NXBpgBetFBaSJacEvQKS4USK9EfAr │ +│ └── │ +│ Gas Object: │ +│ ┌── │ +│ │ ID: 0xc62a5e163e599729509d6cebde097cac04e5d1b3bbc9a169144e8dfa602a0768 │ +│ │ Owner: Account Address ( 0xfc9a64c928a09725cfe01478ad50c2418320b4c079d944ed430eff0f30666a35 ) │ +│ │ Version: 289574880 │ +│ │ Digest: DWmLziJZEHwhkAfdBWVhn8HnJU7DMepDmjVLps2peSx8 │ +│ └── │ +│ Gas Cost Summary: │ +│ Storage Cost: 1976000 MIST │ +│ Computation Cost: 1000000 MIST │ +│ Storage Rebate: 1956240 MIST │ +│ Non-refundable Storage Fee: 19760 MIST │ +│ │ +│ Transaction Dependencies: │ +│ F6TBXbvdK9fi4BnxZMBkL7QeNyv1612778i12ZPhafJD │ +│ HFi4TniDvgL1jDzgPHjzJhxR8nbavLmPH3LLDnNL5Tqd │ +╰───────────────────────────────────────────────────────────────────────────────────────────────────╯ +╭─────────────────────────────╮ +│ No transaction block events │ +╰─────────────────────────────╯ + +╭──────────────────────────────────────────────────────────────────────────────────────────────────╮ +│ Object Changes │ +├──────────────────────────────────────────────────────────────────────────────────────────────────┤ +│ Mutated Objects: │ +│ ┌── │ +│ │ ObjectID: 0xc62a5e163e599729509d6cebde097cac04e5d1b3bbc9a169144e8dfa602a0768 │ +│ │ Sender: 0xfc9a64c928a09725cfe01478ad50c2418320b4c079d944ed430eff0f30666a35 │ +│ │ Owner: Account Address ( 0xfc9a64c928a09725cfe01478ad50c2418320b4c079d944ed430eff0f30666a35 ) │ +│ │ ObjectType: 0x2::coin::Coin<0x2::sui::SUI> │ +│ │ Version: 289574880 │ +│ │ Digest: DWmLziJZEHwhkAfdBWVhn8HnJU7DMepDmjVLps2peSx8 │ +│ └── │ +│ ┌── │ +│ │ ObjectID: 0xe7acb59c190d7fcfcb622916e929c92007f6da15128fd84c8a2afd94a39edf11 │ +│ │ Sender: 0xfc9a64c928a09725cfe01478ad50c2418320b4c079d944ed430eff0f30666a35 │ +│ │ Owner: Account Address ( 0x65437300e280695a40df8cf524c7bca6ad62574cac3a52d3b085ad628c797241 ) │ +│ │ ObjectType: 0x2::coin::Coin<0x2::sui::SUI> │ +│ │ Version: 289574880 │ +│ │ Digest: JBA6PrhWuTUJ3P8NXBpgBetFBaSJacEvQKS4USK9EfAr │ +│ └── │ +╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ +╭───────────────────────────────────────────────────────────────────────────────────────────────────╮ +│ Balance Changes │ +├───────────────────────────────────────────────────────────────────────────────────────────────────┤ +│ ┌── │ +│ │ Owner: Account Address ( 0x65437300e280695a40df8cf524c7bca6ad62574cac3a52d3b085ad628c797241 ) │ +│ │ CoinType: 0x2::sui::SUI │ +│ │ Amount: 1000000000 │ +│ └── │ +│ ┌── │ +│ │ Owner: Account Address ( 0xfc9a64c928a09725cfe01478ad50c2418320b4c079d944ed430eff0f30666a35 ) │ +│ │ CoinType: 0x2::sui::SUI │ +│ │ Amount: -1001019760 │ +│ └── │ +╰───────────────────────────────────────────────────────────────────────────────────────────────────╯ ``` +
## Related links - [Multisig](../../../concepts/cryptography/transaction-auth/multisig.mdx): Definition of multisig transactions on the Sui network and how to use it with CLI. -- [Multisig Typescript SDK](https://sdk.mystenlabs.com/typescript/cryptography/multisig): How to create multisig addresses and sign transactions using the Sui SDK. \ No newline at end of file +- [Multisig Typescript SDK](https://sdk.mystenlabs.com/typescript/cryptography/multisig): How to create multisig addresses and sign transactions using the Sui SDK. +- [SDK documentation](https://sdk.mystenlabs.com/typescript/cryptography/multisig): See the Sui TypeScript SDK documentation to learn how to use the library with multisig transactions. +- [Sui CLI](../../../references/cli.mdx): Interact with the Sui network, its features, and the Move programming language from a command line. \ No newline at end of file