@mysten/sui 2.16.3 → 2.18.0

package/src/jsonRpc/types/params.ts

@@ -135,8 +135,8 @@ export interface GetObjectParams {
 	signal?: AbortSignal;
 }
 /**
- * Return the protocol config table for the given version number. If the version number is not
- * specified, If none is specified, the node uses the version of the latest epoch it has processed.
+ * Return the protocol config table for the given version number. If none is specified, the node uses
+ * the version of the latest epoch it has processed.
  */
 export interface GetProtocolConfigParams {
 	/**
@@ -520,7 +520,7 @@ export interface UnsafePayAllSuiParams {
  * input_coin to create new coin following the order of amounts and assign it to the corresponding
  * recipient. 2. accumulate all residual SUI from input coins left and deposit all SUI to the first
  * input coin, then use the first input coin as the gas coin object. 3. the balance of the first input
- * coin after tx is sum(input_coins) - sum(amounts) - actual_gas_cost 4. all other input coints other
+ * coin after tx is sum(input_coins) - sum(amounts) - actual_gas_cost 4. all other input coins other
  * than the first one are deleted.
  */
 export interface UnsafePaySuiParams {
@@ -591,7 +591,7 @@ export interface UnsafeRequestWithdrawStakeParams {
 export interface UnsafeSplitCoinParams {
 	/** the transaction signer's Sui address */
 	signer: string;
-	/** the coin object to be spilt */
+	/** the coin object to be split */
 	coinObjectId: string;
 	/** the amounts to split out from the coin */
 	splitAmounts: string[];
@@ -608,7 +608,7 @@ export interface UnsafeSplitCoinParams {
 export interface UnsafeSplitCoinEqualParams {
 	/** the transaction signer's Sui address */
 	signer: string;
-	/** the coin object to be spilt */
+	/** the coin object to be split */
 	coinObjectId: string;
 	/** the number of coins to split into */
 	splitCount: string;

package/src/transactions/Transaction.ts

@@ -139,6 +139,17 @@ type TransactionLike = {
 	getData(): unknown;
 };
 
+export interface TransactionCopyOptions {
+	/**
+	 * A map of intent names to resolvers for any custom intents used in the transaction being copied.
+	 *
+	 * Built-in intents (such as `CoinWithBalance`) are handled automatically. Providing resolvers for
+	 * custom intents lets `Transaction.from` copy a transaction synchronously even when it still
+	 * contains unresolved intents, without first awaiting `prepareForSerialization`.
+	 */
+	intentResolvers?: Record<string, TransactionPlugin>;
+}
+
 /**
  * Transaction Builder
  */
@@ -175,8 +186,15 @@ export class Transaction {
 	 * There are two supported serialized formats:
 	 * - A string returned from `Transaction#serialize`. The serialized format must be compatible, or it will throw an error.
 	 * - A byte array (or base64-encoded bytes) containing BCS transaction data.
+	 *
+	 * When copying an in-memory transaction that uses custom intents, pass resolvers for those intents
+	 * via `options.intentResolvers` so the copy can be created synchronously without first awaiting
+	 * `prepareForSerialization`. Built-in intents (such as `CoinWithBalance`) are handled automatically.
 	 */
-	static from(transaction: string | Uint8Array | TransactionLike) {
+	static from(
+		transaction: string | Uint8Array | TransactionLike,
+		options: TransactionCopyOptions = {},
+	) {
 		const newTransaction = new Transaction();
 
 		if (isTransaction(transaction)) {
@@ -195,14 +213,27 @@ export class Transaction {
 		newTransaction.#commandSection = newTransaction.#data.commands.slice();
 		newTransaction.#availableResults = new Set(newTransaction.#commandSection.map((_, i) => i));
 
-		if (!newTransaction.isPreparedForSerialization({ supportedIntents: [COIN_WITH_BALANCE] })) {
+		// Built-in intents are resolvable by default. Caller-supplied resolvers cover custom intents,
+		// and take precedence so a built-in resolver can be overridden if needed.
+		const intentResolvers = new Map<string, TransactionPlugin>([
+			[COIN_WITH_BALANCE, resolveCoinBalance],
+			...Object.entries(options.intentResolvers ?? {}),
+		]);
+
+		if (
+			!newTransaction.isPreparedForSerialization({
+				supportedIntents: [...intentResolvers.keys()],
+			})
+		) {
 			throw new Error(
-				'Transaction has unresolved intents or async thunks. Call `prepareForSerialization` before copying.',
+				'Transaction has unresolved intents or async thunks. Provide resolvers for any custom intents via the `intentResolvers` option, or call `prepareForSerialization` before copying.',
 			);
 		}
 
-		if (newTransaction.#data.commands.some((cmd) => cmd.$Intent?.name === COIN_WITH_BALANCE)) {
-			newTransaction.addIntentResolver(COIN_WITH_BALANCE, resolveCoinBalance);
+		// Register every resolver so the copy can resolve its intents on build. Resolvers for intents
+		// that aren't present are harmless — a resolver only runs when its intent appears in the data.
+		for (const [intent, resolver] of intentResolvers) {
+			newTransaction.addIntentResolver(intent, resolver);
 		}
 
 		return newTransaction;

package/src/transactions/index.ts

@@ -17,6 +17,7 @@ export {
 	type TransactionObjectInput,
 	type TransactionObjectArgument,
 	type TransactionResult,
+	type TransactionCopyOptions,
 } from './Transaction.js';
 
 export { type SerializedTransactionDataV2 } from './data/v2.js';

package/src/version.ts

@@ -3,4 +3,4 @@
 
 // This file is generated by genversion.mjs. Do not edit it directly.
 
-export const PACKAGE_VERSION = '2.16.3';
+export const PACKAGE_VERSION = '2.18.0';

package/src/zklogin/jwt-utils.ts

@@ -116,6 +116,9 @@ export function extractClaimValue<R>(claim: Claim, claimName: string): R {
 	return value;
 }
 
+// TODO: root cause of the claim-escaping bug — jwtDecode resolves JSON escapes, but the
+// circuit derives the address seed from raw JWT bytes, so escaped claim values decode
+// differently here than the circuit hashes. Real fix: parse claims over raw bytes.
 export function decodeJwt(jwt: string): Omit<JwtPayload, 'iss' | 'aud' | 'sub'> & {
 	iss: string;
 	aud: string;

package/src/zklogin/utils.ts

@@ -87,6 +87,20 @@ export function hashASCIIStrToField(str: string, maxSize: number) {
 	return poseidonHash(packed);
 }
 
+// Reject claim inputs whose decoded form reveals a JSON escape ('"', '\', control char):
+// the circuit hashes raw JWT bytes, so an escaped value would derive a different address.
+function assertNoJsonEscape(value: string, label: string) {
+	for (let i = 0; i < value.length; i++) {
+		const c = value.charCodeAt(i);
+		if (c < 0x20 || c === 0x22 || c === 0x5c) {
+			throw new Error(
+				`zkLogin ${label} contains a JSON-escaped character (code ${c}); the circuit ` +
+					`hashes raw JWT bytes, so claim values with escapes are not supported`,
+			);
+		}
+	}
+}
+
 export function genAddressSeed(
 	salt: string | bigint,
 	name: string,
@@ -96,6 +110,9 @@ export function genAddressSeed(
 	max_value_length = MAX_KEY_CLAIM_VALUE_LENGTH,
 	max_aud_length = MAX_AUD_VALUE_LENGTH,
 ): bigint {
+	assertNoJsonEscape(name, 'key claim name');
+	assertNoJsonEscape(value, 'key claim value');
+	assertNoJsonEscape(aud, 'aud');
 	return poseidonHash([
 		hashASCIIStrToField(name, max_name_length),
 		hashASCIIStrToField(value, max_value_length),

package/docs/faucet.md

@@ -1,26 +0,0 @@
-# Faucet
-
-> Request test SUI tokens from the faucet on Devnet, Testnet, or local networks.
-
-Devnet, Testnet, and local networks include faucets that mint SUI. You can use the Sui TypeScript
-SDK to call a network's faucet and provide SUI to the address you provide.
-
-To request SUI from a faucet, import the `requestSuiFromFaucetV2` function from the
-`@mysten/sui/faucet` package to your project.
-
-```typescript
-
-```
-
-Use `requestSuiFromFaucetV2` in your TypeScript code to request SUI from the network's faucet.
-
-```typescript
-await requestSuiFromFaucetV2({
-	host: getFaucetHost('testnet'),
-	recipient: <RECIPIENT_ADDRESS>,
-});
-```
-
-> **Note:** Faucets on Devnet and Testnet are rate limited. If you run the script too many times, you surpass
-> the limit and must wait to successfully run it again. For Testnet, the best way to get SUI is
-> through the Web UI: `faucet.sui.io`.

package/docs/hello-sui.md

@@ -1,115 +0,0 @@
-# Hello Sui
-
-> Build your first Sui application with the TypeScript SDK.
-
-This basic example introduces you to the Sui TypeScript SDK. The Node.js example mints SUI on a Sui
-network and then queries the address to get a sum for the owned SUI. You don't need to use an IDE to
-complete the example, but one like Microsoft Visual Studio Code helps centralize more advanced
-projects.
-
-## Before you begin
-
-You need an address on a Sui development network (Devnet, Testnet, or local). If you don't already
-have an address, use the [Sui Client CLI](https://docs.sui.io/references/cli/client) or the
-[Sui Wallet browser extension](https://docs.mystenlabs.com) to create one.
-
-You also need [Node.js](https://nodejs.org/en/download/current) and a package manager like
-[pnpm](https://pnpm.io/installation) to follow this example, so install them on your system if you
-haven't already.
-
-## Start a project
-
-Using a Terminal or Console, create a folder on your system (`hello-sui` in this example) and make
-it the working directory.
-
-```sh
-mkdir hello-sui
-cd hello-sui
-```
-
-When you use a package manager to install the necessary packages, it downloads the modules to your
-`node_modules` folder and adds the references to your `package.json` file, creating the file if it
-doesn't already exist. For this example, you need only the Sui TypeScript SDK:
-
-```sh npm2yarn
-npm i -D @mysten/sui
-```
-
-The SDK is published as an ESM only package, so you also need to set `"type": "module"` in your
-`package.json`. Your `package.json` file should look like this:
-
-```json
-{
-	"type": "module",
-	"dependencies": {
-		"@mysten/sui": "^<VERSION_NUMBER>"
-	}
-}
-```
-
-## Get some SUI for your account
-
-Instead of a 'Hello World' output to your console, this example introduces some SUI to your wallet
-address. You must be on Devnet, Testnet, or a local network to use a faucet for minting SUI.
-
-Create a new `index.js` file in the root of your project with the following code.
-
-```js
-
-// replace <YOUR_SUI_ADDRESS> with your actual address, which is in the form 0x123...
-const MY_ADDRESS = '<YOUR_SUI_ADDRESS>';
-
-// create a new SuiGrpcClient object pointing to the network you want to use
-const suiClient = new SuiGrpcClient({
-	network: 'devnet',
-	baseUrl: 'https://fullnode.devnet.sui.io:443',
-});
-
-// Convert MIST to Sui
-const balance = (balance) => {
-	return Number.parseInt(balance.totalBalance) / Number(MIST_PER_SUI);
-};
-
-// store the JSON representation for the SUI the address owns before using faucet
-const suiBefore = await suiClient.getBalance({
-	owner: MY_ADDRESS,
-});
-
-await requestSuiFromFaucetV2({
-	// use getFaucetHost to make sure you're using correct faucet address
-	// you can also just use the address (see Sui TypeScript SDK Quick Start for values)
-	host: getFaucetHost('devnet'),
-	recipient: MY_ADDRESS,
-});
-
-// store the JSON representation for the SUI the address owns after using faucet
-const suiAfter = await suiClient.getBalance({
-	owner: MY_ADDRESS,
-});
-
-// Output result to console.
-console.log(
-	`Balance before faucet: ${balance(suiBefore)} SUI. Balance after: ${balance(
-		suiAfter,
-	)} SUI. Hello, SUI!`,
-);
-```
-
-Save the file, then use Node.js to run it in your Console or Terminal:
-
-```sh
-node index.js
-```
-
-The code imports the `requestSuiFromFaucetV2` function from the SDK and calls it to mint SUI for the
-provided address. The code also imports `SuiGrpcClient` to create a new client on the Sui network
-that it uses to query the address and output the amount of SUI the address owns before and after
-using the faucet. You can check the total SUI for your address using the Sui Wallet or Sui Client
-CLI.
-
-> **Note:** Faucets on Devnet and Testnet are rate limited. If you run the script too many times, you surpass
-> the limit and must wait to successfully run it again. For Testnet, the best way to get SUI is
-> through the Web UI: `faucet.sui.io`.
-
-You can also use the [Sui Client CLI](https://docs.sui.io/references/cli/client) to perform client
-calls on a Sui network.

package/docs/install.md

@@ -1,61 +0,0 @@
-# Install Sui TypeScript SDK
-
-> Install the @mysten/sui package and configure your project.
-
-The Sui TypeScript SDK is available in the
-[Sui TS SDK monorepo](https://github.com/MystenLabs/ts-sdks) and NPM.
-
-## Install from NPM
-
-To use the Sui TypeScript SDK in your project, run the following command in your project root:
-
-```sh npm2yarn
-npm i @mysten/sui
-```
-
-The SDK is published as an ESM only package. Make sure your `package.json` includes
-`"type": "module"`:
-
-```json
-{
-	"type": "module"
-}
-```
-
-If you are using TypeScript, your `tsconfig.json` should use a compatible `moduleResolution` setting
-such as `"NodeNext"`, `"Node16"`, or `"Bundler"`. See the
-[2.0 migration guide](/sui/migrations/sui-2.0#esm-migration) for more details.
-
-## Experimental tag for use with a local Sui network
-
-Projects developing against one of the onchain Sui networks (Devnet, Testnet, Mainnet) should use
-the base SDK published in the NPM registry (previous section) because the code aligns with the
-relevant JSON-RPC. If you are developing against a
-[local network](https://docs.sui.io/guides/developer/getting-started/local-network) built from the
-`main` branch of the Sui monorepo, however, you should use the `experimental`-tagged SDK package as
-it contains the latest features (or a local build detailed in the section that follows).
-
-```sh npm2yarn
-npm i @mysten/sui@experimental
-```
-
-## Install from local build
-
-To build the SDK from the Sui monorepo, you must use [pnpm](https://pnpm.io/). With pnpm installed,
-run the following command from the `sui` root directory:
-
-```bash
-# Install all dependencies
-pnpm install
-# Run the build for the TypeScript SDK
-pnpm sdk build
-```
-
-With the SDK built, you can import the library from your `sui` project. To do so, use a path to the
-`ts-sdks/packages/sui` directory that is relative to your project. For example, if you created a
-folder `my-sui-project` at the same level as `sui`, use the following to import the locally built
-Sui TypeScript package:
-
-```bash
-pnpm add ../ts-sdks/packages/sui
-```

package/docs/transaction-building/basics.md

@@ -1,299 +0,0 @@
-# Sui Programmable Transaction Basics
-
-> Construct programmable transaction blocks with the Transaction API.
-
-This example starts by constructing a transaction to send SUI. To construct transactions, import the
-`Transaction` class and construct it:
-
-```tsx
-
-const tx = new Transaction();
-```
-
-You can then add commands to the transaction .
-
-```tsx
-// create a new coin with balance 100, based on the coins used as gas payment
-// you can define any balance here
-const [coin] = tx.splitCoins(tx.gas, [100]);
-
-// transfer the split coin to a specific address
-tx.transferObjects([coin], '0xSomeSuiAddress');
-```
-
-You can attach multiple commands of the same type to a transaction, as well. For example, to get a
-list of transfers and iterate over them to transfer coins to each of them:
-
-```tsx
-interface Transfer {
-	to: string;
-	amount: number;
-}
-
-// procure a list of some Sui transfers to make
-const transfers: Transfer[] = getTransfers();
-
-const tx = new Transaction();
-
-// first, split the gas coin into multiple coins
-const coins = tx.splitCoins(
-	tx.gas,
-	transfers.map((transfer) => transfer.amount),
-);
-
-// next, create a transfer command for each coin
-transfers.forEach((transfer, index) => {
-	tx.transferObjects([coins[index]], transfer.to);
-});
-```
-
-After you have the transaction defined, you can directly execute it with a signer using
-`signAndExecuteTransaction`.
-
-```tsx
-const result = await client.signAndExecuteTransaction({ signer: keypair, transaction: tx });
-
-// IMPORTANT: Always check the transaction status
-// Transactions can execute but still fail (e.g., insufficient gas, move errors)
-if (result.$kind === 'FailedTransaction') {
-	throw new Error(`Transaction failed: ${result.FailedTransaction.status.error?.message}`);
-}
-```
-
-## Observing the results of a transaction
-
-When you use `client.signAndExecuteTransaction` or `client.executeTransactionBlock`, the transaction
-will be finalized on the blockchain before the function resolves, but the effects of the transaction
-might not be immediately observable.
-
-There are 2 ways to observe the results of a transaction. Methods like
-`client.signAndExecuteTransaction` accept an `options` object with options like `showObjectChanges`
-and `showBalanceChanges` (see
-[the SuiJsonRpcClient docs for more details](/sui/clients/json-rpc#arguments)). These options will
-cause the request to contain additional details about the effects of the transaction that can be
-immediately displayed to the user, or used for further processing in your application.
-
-The other way effects of transactions can be observed is by querying other RPC methods like
-`client.getBalances` that return objects or balances owned by a specific address. These RPC calls
-depend on the RPC node having indexed the effects of the transaction, which might not have happened
-immediately after a transaction has been executed. To ensure that effects of a transaction are
-represented in future RPC calls, you can use the `waitForTransaction` method on the client:
-
-```typescript
-const result = await client.signAndExecuteTransaction({ signer: keypair, transaction: tx });
-
-// Check transaction status
-if (result.$kind === 'FailedTransaction') {
-	throw new Error(`Transaction failed: ${result.FailedTransaction.status.error?.message}`);
-}
-
-await client.waitForTransaction({ result });
-```
-
-Once `waitForTransaction` resolves, any future RPC calls will be guaranteed to reflect the effects
-of the transaction.
-
-## Transactions
-
-Programmable Transactions have two key concepts: inputs and commands.
-
-Commands are steps of execution in the transaction. Each command in a Transaction takes a set of
-inputs, and produces results. The inputs for a transaction depend on the kind of command. Sui
-supports following commands:
-
-- `tx.splitCoins(coin, amounts)`: Creates new coins with the defined amounts, split from the
-  provided coin. Returns the coins so that it can be used in subsequent transactions.
-  - Example: `tx.splitCoins(tx.gas, [100, 200])`
-- `tx.mergeCoins(destinationCoin, sourceCoins)`: Merges the sourceCoins into the destinationCoin.
-  - Example: `tx.mergeCoins(tx.object(coin1), [tx.object(coin2), tx.object(coin3)])`
-- `tx.transferObjects(objects, address)`: Transfers a list of objects to the specified address.
-  - Example: `tx.transferObjects([tx.object(thing1), tx.object(thing2)], myAddress)`
-- `tx.moveCall({ target, arguments, typeArguments  })`: Executes a Move call. Returns whatever the
-  Sui Move call returns.
-  - Example:
-    `tx.moveCall({ target: '0x2::devnet_nft::mint', arguments: [tx.pure.string(name), tx.pure.string(description), tx.pure.string(image)] })`
-- `tx.makeMoveVec({ type, elements })`: Constructs a vector of objects that can be passed into a
-  `moveCall`. This is required as there’s no way to define a vector as an input.
-  - Example: `tx.makeMoveVec({ elements: [tx.object(id1), tx.object(id2)] })`
-- `tx.publish(modules, dependencies)`: Publishes a Move package. Returns the upgrade capability
-  object.
-
-## Passing inputs to a command
-
-Command inputs can be provided in a number of different ways, depending on the command, and the type
-of value being provided.
-
-#### JavaScript values
-
-For specific command arguments (`amounts` in `splitCoins`, and `address` in `transferObjects`) the
-expected type is known ahead of time, and you can directly pass raw javascript values when calling
-the command method. appropriate Move type automatically.
-
-```ts
-// the amount to split off the gas coin is provided as a pure javascript number
-const [coin] = tx.splitCoins(tx.gas, [100]);
-// the address for the transfer is provided as a pure javascript string
-tx.transferObjects([coin], '0xSomeSuiAddress');
-```
-
-#### Pure values
-
-When providing inputs that are not on chain objects, the values must be serialized as
-
-[BCS](https://sdk.mystenlabs.com/bcs), which can be done using `tx.pure`, for example
-`tx.pure.address(address)` or `tx.pure(bcs.vector(bcs.U8).serialize(bytes))`.
-
-`tx.pure` can be called as a function that accepts a SerializedBcs object, or as a namespace that
-contains functions for each of the supported types.
-
-```ts
-const [coin] = tx.splitCoins(tx.gas, [tx.pure.u64(100)]);
-const [coin] = tx.splitCoins(tx.gas, [tx.pure(bcs.U64.serialize(100))]);
-tx.transferObjects([coin], tx.pure.address('0xSomeSuiAddress'));
-tx.transferObjects([coin], tx.pure(bcs.Address.serialize('0xSomeSuiAddress')));
-```
-
-To pass `vector` or `option` types, you can pass use the corresponding methods on `tx.pure`, use
-tx.pure as a function with a type argument, or serialize the value before passing it to tx.pure
-using the bcs sdk:
-
-```ts
-
-tx.moveCall({
-	target: '0x2::foo::bar',
-	arguments: [
-		// using vector and option methods
-		tx.pure.vector('u8', [1, 2, 3]),
-		tx.pure.option('u8', 1),
-		tx.pure.option('u8', null),
-
-		// Using pure with type arguments
-		tx.pure('vector<u8>', [1, 2, 3]),
-		tx.pure('option<u8>', 1),
-		tx.pure('option<u8>', null),
-		tx.pure('vector<option<u8>>', [1, null, 2]),
-
-		// Using bcs.serialize
-		tx.pure(bcs.vector(bcs.U8).serialize([1, 2, 3])),
-		tx.pure(bcs.option(bcs.U8).serialize(1)),
-		tx.pure(bcs.option(bcs.U8).serialize(null)),
-		tx.pure(bcs.vector(bcs.option(bcs.U8)).serialize([1, null, 2])),
-	],
-});
-```
-
-#### Object references
-
-To use an on chain object as a transaction input, you must pass a reference to that object. This can
-be done by calling `tx.object` with the object id. Transaction arguments that only accept objects
-(like `objects` in `transferObjects`) will automatically treat any provided strings as objects ids.
-For methods like `moveCall` that accept both objects and other types, you must explicitly call
-`tx.object` to convert the id to an object reference.
-
-```ts
-// Object IDs can be passed to some methods like (transferObjects) directly
-tx.transferObjects(['0xSomeObject'], 'OxSomeAddress');
-// tx.object can be used anywhere an object is accepted
-tx.transferObjects([tx.object('0xSomeObject')], 'OxSomeAddress');
-
-tx.moveCall({
-	target: '0x2::nft::mint',
-	// object IDs must be wrapped in moveCall arguments
-	arguments: [tx.object('0xSomeObject')],
-});
-
-// tx.object automatically converts the object ID to receiving transaction arguments if the moveCall expects it
-tx.moveCall({
-	target: '0xSomeAddress::example::receive_object',
-	// 0xSomeAddress::example::receive_object expects a receiving argument and has a Move definition that looks like this:
-	// public fun receive_object<T: key>(parent_object: &mut ParentObjectType, receiving_object: Receiving<ChildObjectType>) { ... }
-	arguments: [tx.object('0xParentObjectID'), tx.object('0xReceivingObjectID')],
-});
-```
-
-When building a transaction, Sui expects all objects to be fully resolved, including the object
-version. The SDK automatically looks up the current version of objects for any provided object
-reference when building a transaction. If the object reference is used as a receiving argument to a
-`moveCall`, the object reference is automatically converted to a receiving transaction argument.
-This greatly simplifies building transactions, but requires additional RPC calls. You can optimize
-this process by providing a fully resolved object reference instead:
-
-```ts
-// for owned or immutable objects
-tx.object(Inputs.ObjectRef({ digest, objectId, version }));
-
-// for shared objects
-tx.object(Inputs.SharedObjectRef({ objectId, initialSharedVersion, mutable }));
-
-// for receiving objects
-tx.object(Inputs.ReceivingRef({ digest, objectId, version }));
-```
-
-##### Object helpers
-
-There are a handful of specific object types that can be referenced through helper methods on
-tx.object:
-
-```ts
-tx.object.system(),
-tx.object.clock(),
-tx.object.random(),
-tx.object.denyList(),
-
-tx.object.option({
-	type: '0x123::example::Thing',
-	// value can be an Object ID, or any other object reference, or null for `none`
-	value: '0x456',
-}),
-```
-
-#### Transaction results
-
-You can also use the result of a command as an argument in a subsequent commands. Each method on the
-transaction builder returns a reference to the transaction result.
-
-```tsx
-// split a coin object off of the gas object
-const [coin] = tx.splitCoins(tx.gas, [100]);
-// transfer the resulting coin object
-tx.transferObjects([coin], address);
-```
-
-When a command returns multiple results, you can access the result at a specific index either using
-destructuring, or array indexes.
-
-```tsx
-// destructuring (preferred, as it gives you logical local names)
-const [nft1, nft2] = tx.moveCall({ target: '0x2::nft::mint_many' });
-tx.transferObjects([nft1, nft2], address);
-
-// array indexes
-const mintMany = tx.moveCall({ target: '0x2::nft::mint_many' });
-tx.transferObjects([mintMany[0], mintMany[1]], address);
-```
-
-## Get transaction bytes
-
-If you need the transaction bytes, instead of signing or executing the transaction, you can use the
-`build` method on the transaction builder itself.
-
-You might need to explicitly call `setSender()` on the transaction to ensure that the `sender` field
-is populated. This is normally done by the signer before signing the transaction, but will not be
-done automatically if you’re building the transaction bytes yourself.
-
-```tsx
-const tx = new Transaction();
-
-// ... add some transactions...
-
-await tx.build({ client });
-```
-
-In most cases, building requires your SuiJsonRpcClient to fully resolve input values.
-
-If you have transaction bytes, you can also convert them back into a `Transaction` class:
-
-```tsx
-const bytes = getTransactionBytesFromSomewhere();
-const tx = Transaction.from(bytes);
-```