@mysten/sui 2.6.0 → 2.8.0

package/docs/executors.md

@@ -0,0 +1,147 @@
+# Transaction Executors
+
+> Manage transaction execution with queuing and parallel strategies
+
+The Typescript SDK ships 2 Transaction executor classes that simplify the processes of efficiently
+executing multiple transactions signed by the same address. These executors help manage object
+versions and gas coins which significantly reduces the number of requests made to RPC nodes, and for
+many cases avoids the need to wait for the RPC nodes to index previously executed transactions.
+
+## `SerialTransactionExecutor`
+
+The `SerialTransactionExecutor` is designed for use in wallet implementations, and dapps where the
+objects owned by the address executing transactions are unlikely to be changed by transactions not
+executed through the executor.
+
+To fund transactions, the `SerialTransactionExecutor` will select all of the senders SUI coins for
+the first transaction, which will result in a single coin that will then be used as the gas payment
+on all subsequent transactions. This allows executing multiple transactions, without needing to
+re-query for gas coins, or wait for the RPC node to index the previous transactions.
+
+To further improve execution efficiency, the `SerialTransactionExecutor` caches the object versions
+of every object used or created by a transaction. This will significantly speed up the execution
+when multiple transactions use the same objects.
+
+`SerialTransactionExecutor` maintains an internal queue, so you don't need to wait for previous
+transactions to finish before sending the next one.
+
+`SerialTransactionExecutor` can be configured with a number of options:
+
+- `client`: An instance of a Sui client (such as `SuiGrpcClient`) used to execute transactions.
+- `signer`: The signer/keypair used for signed transactions.
+- `defaultBudget`: The default budget for transactions, which will be used if the transaction does
+  not specify a budget (default `50_000_000n`).
+- `gasMode`: Either `'coins'` (default) to use owned coins for gas, or `'addressBalance'` to pay gas
+  from the sender's address balance.
+
+```ts
+const client = new SuiGrpcClient({
+	network: 'devnet',
+	baseUrl: 'https://fullnode.devnet.sui.io:443',
+});
+
+const executor = new SerialTransactionExecutor({
+	client,
+	signer: yourKeyPair,
+});
+
+const tx1 = new Transaction();
+const [coin1] = tx1.splitCoins(tx1.gas, [1]);
+tx1.transferObjects([coin1], address1);
+const tx2 = new Transaction();
+const [coin2] = tx2.splitCoins(tx2.gas, [1]);
+tx2.transferObjects([coin2], address2);
+
+const [{ digest: digest1 }, { digest: digest2 }] = await Promise.all([
+	executor.executeTransaction(tx1),
+	executor.executeTransaction(tx2),
+]);
+```
+
+## `ParallelTransactionExecutor`
+
+> **Warning:** `ParallelTransactionExecutor` is experimental and may change rapidly as it is being
+> developed.
+
+The `ParallelTransactionExecutor` class works similarly to the `SerialTransactionExecutor`, but
+allows for parallel execution of transactions. To make this work, the `ParallelTransactionExecutor`
+will maintain a pool of gas coins, and automatically execute additional transactions to refill the
+gas pool as needed.
+
+> **Warning:** Using other client methods or wallets to execute additional transactions while
+> `ParallelTransactionExecutor` is in use may consume/combine gas coins in the gasPool, causing
+> transactions to fail. This may also result in the coins becoming locked for the remainder of the
+> current epoch, preventing them from being used in future transactions.
+>
+> Running multiple instances of `ParallelTransactionExecutor` using the same `sourceCoins` will
+> result in the same issues.
+
+In addition to managing gas and caching object versions, the `ParallelTransactionExecutor` will
+automatically detect what objects are being used by transactions, and schedules transactions in a
+way that avoids conflicts between transactions using the same object ids.
+
+`ParallelTransactionExecutor` can be configured with a number of options:
+
+- `client`: An instance of `SuiJsonRpcClient` used to execute transactions.
+- `signer`: The signer/keypair used for signed transactions.
+- `gasMode`: Either `'coins'` (default) to use owned coins for gas, or `'addressBalance'` to pay gas
+  from the sender's address balance. When using `'addressBalance'`, coin-specific options like
+  `coinBatchSize`, `initialCoinBalance`, `minimumCoinBalance`, and `sourceCoins` are not available.
+- `coinBatchSize`: The maximum number of new coins to create when refilling the gas pool
+  (default 20)
+- `initialCoinBalance`: The balance of new coins created for the gas pool in MIST (default
+  `200_000_000n`),
+- `minimumCoinBalance`: After executing a transaction, the gasCoin will be reused unless it's
+  balance is below this value (default `50_000_000n`),
+- `defaultBudget`: The default budget for transactions, which will be used if the transaction does
+  not specify a budget (default `minimumCoinBalance`),
+- `maxPoolSize`: The maximum number of gas coins to keep in the gas pool, which also limits the
+  maximum number of concurrent transactions (default 50),
+- `sourceCoins`: An array of coins to use to create the gas pool, defaults to using all coins owned
+  by the signer.
+- `epochBoundaryWindow` Time to wait before/after the expected epoch boundary before re-fetching the
+  gas pool (in milliseconds). Building transactions will be paused for up to 2x this duration around
+  each epoch boundary to ensure the gas price is up-to-date for the next epoch. (default `1000`)
+
+```ts
+const client = new SuiJsonRpcClient({ url: getJsonRpcFullnodeUrl('devnet'), network: 'devnet' });
+
+const executor = new ParallelTransactionExecutor({
+	client,
+	signer: yourKeyPair,
+});
+
+const tx1 = new Transaction();
+const [coin1] = tx1.splitCoins(tx1.gas, [1]);
+tx1.transferObjects([coin1], address1);
+const tx2 = new Transaction();
+const [coin2] = tx2.splitCoins(tx2.gas, [1]);
+tx2.transferObjects([coin2], address2);
+
+const [{ digest: digest1 }, { digest: digest2 }] = await Promise.all([
+	executor.executeTransaction(tx1),
+	executor.executeTransaction(tx2),
+]);
+```
+
+## Building and Executing Transactions with Executors
+
+The executor classes will significantly improve efficiency when executing multiple transactions, but
+to get the best results there are some best practices to follow:
+
+When building transactions, always prefer using unresolved object IDs rather than specifying the
+full `id`/`version`/`digest` for an object input (eg use `tx.object(id)` rather than
+`tx.objectRef({ objectId, version, digest })`). By doing this, you allow the executor to use object
+versions and digests from the cache, and will avoid executing transactions using stale object
+versions.
+
+If the signer executes transactions that are not sent through the executor that may cause
+transactions to fail. The executor classes will handle this by invalidating the cache for any
+objects used in the transaction, so you will often be able to recover by re-trying a failed
+transaction once. If it was caused by a stale cache, it should succeed on the second execution.
+
+> **Warning:** Transaction plugins and intents may resolve their own data (such as object
+> references) that are not automatically managed by the executor's object cache. This can cause
+> transactions to include stale object versions. The `coinWithBalance` intent is partially supported
+> by the executors and will work correctly when all coin types are either SUI or the required
+> balances are available as address balances rather than coin objects.

package/docs/faucet.md

@@ -0,0 +1,26 @@
+# Faucet
+
+> Request test SUI tokens from the faucet
+
+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 via the Web UI: `faucet.sui.io`.

package/docs/hello-sui.md

@@ -0,0 +1,114 @@
+# 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, 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 via 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/index.md

@@ -0,0 +1,54 @@
+# Sui TypeScript SDK Quick Start
+
+> TypeScript SDK for building on the Sui blockchain
+
+The Sui TypeScript SDK is a modular library of tools for interacting with the Sui blockchain. Use it
+to send queries to RPC nodes, build and sign transactions, and interact with a Sui or local network.
+
+## Installation
+
+```sh npm2yarn
+npm i @mysten/sui
+```
+
+## Network locations
+
+The following table lists the locations for Sui networks.
+
+| Network | Full node                             | faucet                                   |
+| ------- | ------------------------------------- | ---------------------------------------- |
+| local   | `http://127.0.0.1:9000` (default)     | `http://127.0.0.1:9123/v2/gas` (default) |
+| Devnet  | `https://fullnode.devnet.sui.io:443`  | `https://faucet.devnet.sui.io/v2/gas`    |
+| Testnet | `https://fullnode.testnet.sui.io:443` | `https://faucet.testnet.sui.io/v2/gas`   |
+| Mainnet | `https://fullnode.mainnet.sui.io:443` | `null`                                   |
+
+> **Warning:** Use dedicated nodes/shared services rather than public endpoints for production apps.
+> The public endpoints maintained by Mysten Labs (`fullnode.<NETWORK>.sui.io:443`) are rate-limited,
+> and support only 100 requests per 30 seconds or so. Do not use public endpoints in production
+> applications with high traffic volume.
+>
+> You can either run your own Full nodes, or outsource this to a professional infrastructure
+> provider (preferred for apps that have high traffic). You can find a list of reliable RPC endpoint
+> providers for Sui on the [Sui Dev Portal](https://sui.io/developers#dev-tools) using the **Node
+> Service** tab.
+
+## Module packages
+
+The SDK contains a set of modular packages that you can use independently or together. Import just
+what you need to keep your code light and compact.
+
+- [`@mysten/sui/client`](/sui/clients) - A client for interacting with Sui RPC nodes.
+- [`@mysten/sui/bcs`](/sui/bcs) - A BCS builder with pre-defined types for Sui.
+- [`@mysten/sui/transactions`](/sui/transaction-building/basics) - Utilities for building and
+  interacting with transactions.
+- [`@mysten/sui/keypairs/*`](/sui/cryptography/keypairs) - Modular exports for specific KeyPair
+  implementations.
+- [`@mysten/sui/verify`](/sui/cryptography/keypairs#verifying-signatures-without-a-key-pair) -
+  Methods for verifying transactions and messages.
+- [`@mysten/sui/cryptography`](/sui/cryptography/keypairs) - Shared types and classes for
+  cryptography.
+- [`@mysten/sui/multisig`](/sui/cryptography/multisig) - Utilities for working with multisig
+  signatures.
+- [`@mysten/sui/utils`](/sui/utils) - Utilities for formatting and parsing various Sui types.
+- [`@mysten/sui/faucet`](/sui/faucet) - Methods for requesting SUI from a faucet.
+- [`@mysten/sui/zklogin`](/sui/zklogin) - Utilities for working with zkLogin.

package/docs/install.md

@@ -0,0 +1,61 @@
+# 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 on-chain 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 your 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/llm-docs.md

@@ -0,0 +1,32 @@
+# LLM Documentation
+
+> Give AI agents access to Sui SDK documentation in your project
+
+Every `@mysten/*` package ships a `docs/` directory containing flat markdown files optimized for AI
+agent consumption. When you install an SDK package, you automatically get accurate, up-to-date
+documentation that coding agents (Claude Code, Cursor, Copilot, etc.) can read directly — no
+separate install or training data required.
+
+## How It Works
+
+Each package includes:
+
+- `docs/llms-index.md` — routing index listing all doc pages with descriptions
+- `docs/*.md` — individual reference pages
+
+For example, installing `@mysten/sui` gives you docs at
+`node_modules/@mysten/sui/docs/llms-index.md`.
+
+## Configure Your Agent
+
+Add the following snippet to your agent's configuration file (`AGENTS.md`, `CLAUDE.md`,
+`.cursorrules`, etc.):
+
+```markdown
+## Sui SDK Reference
+
+Every @mysten/\* package ships LLM documentation in its `docs/` directory. When working with these
+packages, find the relevant docs by looking for `docs/llms-index.md` files inside
+`node_modules/@mysten/\*/`. Read the index first to find the page you need, then read that page for
+details.
+```

package/docs/llms-index.md

@@ -0,0 +1,60 @@
+# Sui SDK
+
+> TypeScript interfaces for Sui
+
+- [Sui TypeScript SDK Quick Start](./index.md): TypeScript SDK for building on the Sui blockchain
+- [Install Sui TypeScript SDK](./install.md): Install the @mysten/sui package and configure your
+  project
+- [LLM Documentation](./llm-docs.md): Give AI agents access to Sui SDK documentation in your project
+- [Hello Sui](./hello-sui.md): Build your first Sui application with the TypeScript SDK
+- [Faucet](./faucet.md): Request test SUI tokens from the faucet
+- [Sui Clients](./clients/index.md): Choose and configure gRPC, GraphQL, or JSON-RPC clients
+- [Core API](./clients/core.md): Transport-agnostic Core API shared by all Sui clients
+- [SuiGrpcClient](./clients/grpc.md): Connect to Sui via gRPC with SuiGrpcClient
+- [SuiGraphQLClient](./clients/graphql.md): Connect to Sui via GraphQL with SuiGraphQLClient
+- [SuiJsonRpcClient](./clients/json-rpc.md): Connect to Sui via JSON-RPC with SuiJsonRpcClient
+- [Sui Programmable Transaction Basics](./transaction-building/basics.md): Construct programmable
+  transaction blocks with the Transaction API
+- [Paying for Sui Transactions with Gas Coins](./transaction-building/gas.md): Configure gas budget,
+  price, and coin selection for transactions
+- [Transaction Intents](./transaction-building/intents.md): Use high-level intents to simplify
+  transaction building
+- [Building Offline](./transaction-building/offline.md): Build transactions without a network
+  connection
+- [Sponsored Transactions](./transaction-building/sponsored-transactions.md): Pay gas fees on behalf
+  of other users with sponsored transactions
+- [Key pairs](./cryptography/keypairs.md): Create and manage Ed25519, Secp256k1, and Secp256r1
+  keypairs
+- [Multi-Signature Transactions](./cryptography/multisig.md): Create multi-signature transactions
+  with multiple signers
+- [Passkey](./cryptography/passkey.md): Use WebAuthn passkeys for Sui transaction signing
+- [Web Crypto Signer](./cryptography/webcrypto-signer.md): Sign transactions using the Web Crypto
+  API
+- [The `@mysten/sui/utils` package](./utils/index.md): Utility functions for addresses, coins, and
+  common operations
+- [Derived Objects](./utils/derived_objects.md): Compute derived object IDs from parent objects
+- [BCS](./bcs.md): Binary Canonical Serialization for encoding Sui Move types
+- [ZkLogin](./zklogin.md): Zero-knowledge authentication with OAuth providers on Sui
+- [Transaction Executors](./executors.md): Manage transaction execution with queuing and parallel
+  strategies
+- [Transaction Plugins](./plugins.md): Extend transaction building with reusable plugins
+- [Building SDKs](./sdk-building.md): Build custom SDKs on top of the Sui TypeScript SDK
+- [Migrate to 2.0](./migrations/sui-2.0/index.md): Migration guide for Sui TypeScript SDK 2.0
+- [Agent Migration Prompt](./migrations/sui-2.0/agent-prompt.md): AI agent prompt for automated SDK
+  2.0 migration
+- [@mysten/sui](./migrations/sui-2.0/sui.md): Migrate @mysten/sui from 1.x to 2.0
+- [Migrating from JSON-RPC](./migrations/sui-2.0/json-rpc-migration.md): Migrate from JSON-RPC to
+  the new Core API
+- [@mysten/dapp-kit](./migrations/sui-2.0/dapp-kit.md): Migrate @mysten/dapp-kit to 2.0
+- [@mysten/kiosk](./migrations/sui-2.0/kiosk.md): Migrate @mysten/kiosk to 2.0
+- [@mysten/zksend](./migrations/sui-2.0/zksend.md): Migrate @mysten/zksend to 2.0
+- [@mysten/suins](./migrations/sui-2.0/suins.md): Migrate @mysten/suins to 2.0
+- [@mysten/deepbook-v3](./migrations/sui-2.0/deepbook-v3.md): Migrate @mysten/deepbook-v3 to 2.0
+- [@mysten/walrus](./migrations/sui-2.0/walrus.md): Migrate @mysten/walrus to 2.0
+- [@mysten/seal](./migrations/sui-2.0/seal.md): Migrate @mysten/seal to 2.0
+- [Wallet Builders](./migrations/sui-2.0/wallet-builders.md): Migration guide for wallet extension
+  developers
+- [SDK Maintainers](./migrations/sui-2.0/sdk-maintainers.md): Migration guide for SDK maintainers
+  and library authors
+- [Migrate to 1.0](./migrations/sui-1.0.md): Migrate to Sui TypeScript SDK 1.0
+- [Migrate to 0.38.0](./migrations/0.38.md): Migrate from SDK version 0.37 to 0.38

package/docs/migrations/0.38.md

@@ -0,0 +1,57 @@
+# Migrate to 0.38.0
+
+> Migrate from SDK version 0.37 to 0.38
+
+> **Warning:** The 1.0 release of the SDK contains many additional changes. This document may help
+> help as an intermediate step when upgrading from older versions of the SDK, but all apps should be
+> upgraded to the latest version of the SDK instead of 0.38.0.
+
+The Sui TypeScript SDK was refactored beginning with version 0.38.0. If you are updating from an
+earlier version of the SDK, there are some changes you should consider when updating your code.
+
+### Module structure
+
+The Sui TypeScript SDK is now divided into modular components. Before version 0.38.0, you imported
+the complete SDK module. Now, you upload the individual packages of the SDK module instead. See the
+[Module Packages section](#module-packages) for the list of packages.
+
+### Deprecated classes
+
+The Sui TypeScript SDK deprecates the following classes with version 0.38.0:
+
+- `JsonRpcProvider` - The `JsonRpcProvider` class is deprecated in favor of the `suiClient` class
+  when creating a client for a Sui network. See
+  [Network Interactions with SuiJsonRpcClient](/sui/clients) for more information.
+- `SignerWithProver` and `RawSigner` - Key pairs now directly support signing transactions and
+  messages without the need of a `Signer` class. See the [Key pairs](/sui/cryptography/keypairs)
+  topic for more information.
+- `signAndExecuteTransaction` - This method was not deprecated, but is now part of
+  `SuiJsonRpcClient`.
+- `Connection` classes - The `Connection` classes (`Connection`, `devnetConnection`, and so on) have
+  been deprecated in favor ofSuiJsonRpcClientuiClient` for establishing the connection. See
+  [Network Interactions with SuiJsonRpcClient](/sui/clients) for more information.
+- The `superstruct` type definitions for `JsonRPCProvider` types are replaced with generated types
+  exported from `@mysten/sui/client`. The new type definitions are pure TypeScript types that you
+  can't use for runtime validation.
+- A more stable JSON-RPC API has reduced the need for many of the SDK "getter" methods, which are
+  now deprecated.
+
+### Signing transactions
+
+Signing and sending transactions changes slightly with the deprecation of the `Signer` pattern. For
+an example of transaction signing, see the
+[Sui Programmable Transaction Blocks Basics](/sui/transaction-building/basics) topic.
+
+### Faucet requests
+
+SuiJsonRpcClient The ability to request SUI from a faucet is not part of `SuiJsonRpcClient` as it
+was with `JsonRpcProvider`. Instead, you must use the `requestSuiFromFaucetV0` method from
+`@mysten/sui/faucet`. The `@mysten/sui/faucet` import also provides a `getFaucetHost` method to
+retrieve the faucet URL for `localnet`, `testnet`, or `devnet` networks.
+
+```ts
+await requestSuiFromFaucetV0({
+	host: getFaucetHost('devnet'),
+	recipient: '<SUI_ADDRESS>',
+});
+```