@mysten/sui 2.16.0 → 2.16.2

package/docs/clients/index.md

@@ -1,32 +1,33 @@
 # Sui Clients
 
-> Choose and configure gRPC, GraphQL, or JSON-RPC clients
+> Choose and configure gRPC, GraphQL, or JSON-RPC clients for the Sui network.
 
 The Sui TypeScript SDK provides multiple client implementations for interacting with the Sui
 network. Each client connects to a different API but provides two levels of access:
 
-- **Native API** - Full access to everything the underlying API offers
-- **[Core API](/sui/clients/core)** - A consistent interface across all clients for common
-  operations
+- Native API: Full access to everything the underlying API offers
+- [Core API](/sui/clients/core): A consistent interface across all clients for common operations
 
-## Available Clients
+## Available clients
 
-| Client                                                 | API                                                                |
-| ------------------------------------------------------ | ------------------------------------------------------------------ |
-| [SuiGrpcClient](/sui/clients/grpc) (recommended)       | [Full Node gRPC](https://docs.sui.io/references/fullnode-protocol) |
-| [SuiGraphQLClient](/sui/clients/graphql)               | [GraphQL](https://docs.sui.io/references/sui-graphql)              |
-| [SuiJsonRpcClient](/sui/clients/json-rpc) (deprecated) | [JSON-RPC (deprecated)](https://docs.sui.io/sui-api-ref)           |
+| Client                                                   | API                                                                |
+| -------------------------------------------------------- | ------------------------------------------------------------------ |
+| [`SuiGrpcClient`](/sui/clients/grpc) (recommended)       | [Full Node gRPC](https://docs.sui.io/references/fullnode-protocol) |
+| [`SuiGraphQLClient`](/sui/clients/graphql)               | [GraphQL](https://docs.sui.io/references/sui-graphql)              |
+| [`SuiJsonRpcClient`](/sui/clients/json-rpc) (deprecated) | [JSON-RPC (deprecated)](https://docs.sui.io/sui-api-ref)           |
 
 All clients are compatible with Mysten SDKs like `@mysten/walrus`, `@mysten/seal` and
 `@mysten/suins`.
 
 For most application gRPC is a good default. The JSON RPC API has been deprecated and will be
 decommissioned soon. The GraphQL can be used for more advanced query patterns that can not be
-supported directly on full nodes (eg, querying for transactions or events with various filters).
+supported directly on full nodes (for example, querying for transactions or events with various
+filters).
 
-## Quick Start
+## Quick start
 
 ```typescript
+
 const client = new SuiGrpcClient({
 	network: 'mainnet',
 	baseUrl: 'https://fullnode.mainnet.sui.io:443',
@@ -39,7 +40,7 @@ const { response } = await client.ledgerService.getTransaction({ digest: '0x...'
 const { object } = await client.core.getObject({ objectId: '0x...' });
 ```
 
-## Native vs Core API
+## Native vs core API
 
 ### Native API
 
@@ -47,6 +48,7 @@ Each client exposes the full capabilities of its underlying transport. Use the n
 need transport-specific features or want maximum control:
 
 ```typescript
+
 // gRPC - access various service clients to call any gRPC method
 const { response } = await grpcClient.stateService.listOwnedObjects({ owner: '0x...' });
 
@@ -78,7 +80,7 @@ await client.core.executeTransaction({ transaction, signatures });
 The Core API is essential for [building SDKs](/sui/sdk-building) that work with any client the user
 chooses.
 
-## Client Extensions
+## Client extensions
 
 All clients support extensions through the `$extend` method, enabling SDKs like
 [@mysten/walrus](https://www.npmjs.com/package/@mysten/walrus) to add functionality:
@@ -90,4 +92,4 @@ const client = new SuiGrpcClient({ network: 'mainnet', baseUrl: '...' }).$extend
 await client.walrus.writeBlob({ ... });
 ```
 
-See [Building SDKs](/sui/sdk-building) for more on creating client extensions.
+See [Building SDKs](/sui/sdk-building) for more on creating client extensions.

package/docs/clients/json-rpc.md

@@ -1,15 +1,16 @@
 # SuiJsonRpcClient
 
-> Connect to Sui via JSON-RPC with SuiJsonRpcClient
+> Connect to Sui through JSON-RPC with SuiJsonRpcClient.
 
 > **Warning:** The Sui JSON-RPC API has been deprecated. We recommend migration to
-> [SuiGrpcClient](/sui/clients/grpc) or [SuiGraphQLClient](/sui/clients/graphql) as soon as
+> [`SuiGrpcClient`](/sui/clients/grpc) or [`SuiGraphQLClient`](/sui/clients/graphql) as soon as
 > possible.
 
 The `SuiJsonRpcClient` connects to a Sui network's JSON-RPC server. It implements the
 [Core API](/sui/clients/core), so it can be used with any SDK that accepts `ClientWithCoreApi`.
 
 ```typescript
+
 const client = new SuiJsonRpcClient({
 	url: getJsonRpcFullnodeUrl('mainnet'),
 	network: 'mainnet',
@@ -26,6 +27,7 @@ the relevant URL to the `url` parameter. The following example establishes a con
 and get all `Coin<coin_type>` objects owned by an address.
 
 ```typescript
+
 // use getJsonRpcFullnodeUrl to define Devnet RPC location
 const rpcUrl = getJsonRpcFullnodeUrl('devnet');
 
@@ -57,6 +59,7 @@ RPC methods are built into `SuiJsonRpcClient`, but you can use `call` to leverag
 available in the RPC.
 
 ```typescript
+
 const client = new SuiJsonRpcClient({
 	url: 'https://fullnode.devnet.sui.io:443',
 });
@@ -75,6 +78,7 @@ websocket requests for subscriptions. You can construct a custom transport insta
 pass any custom options, such as headers or timeout values.
 
 ```typescript
+
 const client = new SuiJsonRpcClient({
 	transport: new JsonRpcHTTPTransport({
 		url: 'https://fullnode.devnet.sui.io:443',
@@ -96,9 +100,9 @@ const client = new SuiJsonRpcClient({
 `SuiJsonRpcClient` exposes a number of RPC methods that return paginated results. These methods
 return a result object with 3 fields:
 
-- data: The list of results for the current page
-- nextCursor: a cursor pointing to the next page of results
-- hasNextPage: a boolean indicating whether there are more pages of results
+- `data`: The list of results for the current page
+- `nextCursor`: A cursor pointing to the next page of results
+- `hasNextPage`: A boolean indicating whether there are more pages of results
 
 Some APIs also accept an `order` option that can be set to either `ascending` or `descending` to
 change the order in which the results are returned.
@@ -146,10 +150,10 @@ const result = await client.executeTransactionBlock({
 
 #### Arguments
 
-- `transactionBlock` - either a Transaction or BCS serialized transaction data bytes as a Uint8Array
+- `transactionBlock`: either a Transaction or BCS serialized transaction data bytes as a Uint8Array
   or as a base-64 encoded string.
-- `signature` - A signature, or list of signatures committed to the intent message of the
-  transaction data, as a base-64 encoded string.
+- `signature`: A signature, or list of signatures committed to the intent message of the transaction
+  data, as a base-64 encoded string.
 - `options`:
   - `showBalanceChanges`: Whether to show balance_changes. Default to be False
   - `showEffects`: Whether to show transaction effects. Default to be False
@@ -181,9 +185,9 @@ if (result.$kind === 'FailedTransaction') {
 
 #### Arguments
 
-- `transaction` - BCS serialized transaction data bytes as a Uint8Array or as a base-64 encoded
+- `transaction`: BCS serialized transaction data bytes as a Uint8Array or as a base-64 encoded
   string.
-- `signer` - A `Keypair` instance to sign the transaction
+- `signer`: A `Keypair` instance to sign the transaction
 - `options`:
   - `showBalanceChanges`: Whether to show balance_changes. Default to be False
   - `showEffects`: Whether to show transaction effects. Default to be False
@@ -195,8 +199,8 @@ if (result.$kind === 'FailedTransaction') {
 ### `waitForTransaction`
 
 Wait for a transaction result to be available over the API. This can be used in conjunction with
-`signAndExecuteTransaction` to wait for the transaction to be available via the API. This currently
-polls the `getTransactionBlock` API to check for the transaction.
+`signAndExecuteTransaction` to wait for the transaction to be available through the API. This
+currently polls the `getTransactionBlock` API to check for the transaction.
 
 ```tsx
 const tx = new Transaction();
@@ -221,10 +225,10 @@ const transaction = await client.waitForTransaction({
 
 #### Arguments
 
-- `digest` - the digest of the queried transaction
-- `signal` - An optional abort signal that can be used to cancel the request
-- `timeout` - The amount of time to wait for a transaction. Defaults to one minute.
-- `pollInterval` - The amount of time to wait between checks for the transaction. Defaults to 2
+- `digest`: the digest of the queried transaction
+- `signal`: An optional abort signal that can be used to cancel the request
+- `timeout`: The amount of time to wait for a transaction. Defaults to one minute.
+- `pollInterval`: The amount of time to wait between checks for the transaction. Defaults to 2
   seconds.
 - `options`:
   - `showBalanceChanges`: Whether to show balance_changes. Default to be False
@@ -232,4 +236,4 @@ const transaction = await client.waitForTransaction({
   - `showEvents`: Whether to show transaction events. Default to be False
   - `showInput`: Whether to show transaction input data. Default to be False
   - `showObjectChanges`: Whether to show object_changes. Default to be False
-  - `showRawInput`: Whether to show bcs-encoded transaction input data
+  - `showRawInput`: Whether to show bcs-encoded transaction input data

package/docs/cryptography/keypairs.md

@@ -1,6 +1,6 @@
 # Key pairs
 
-> Create and manage Ed25519, Secp256k1, and Secp256r1 keypairs
+> Create and manage Ed25519, Secp256k1, and Secp256r1 keypairs for Sui transaction signing.
 
 The Sui TypeScript SDK provides `Keypair` classes that handle logic for signing and verification
 using the cryptographic key pairs associated with a Sui address.
@@ -53,6 +53,7 @@ to retrieve its associated Sui address. You can access a `Keypair` from its `Pub
 it from the bytes (as a `Uint8Array`) of the `PublicKey`, as in the following code:
 
 ```typescript
+
 const keypair = new Ed25519Keypair();
 
 // method 1
@@ -76,6 +77,7 @@ then verifies the message to retrieve the public key. The code then uses `toSuiA
 if the address associated with the public key matches the address that the key pair defines.
 
 ```typescript
+
 const keypair = new Ed25519Keypair();
 const message = new TextEncoder().encode('hello world');
 const { signature } = await keypair.signPersonalMessage(message);
@@ -93,6 +95,7 @@ if (!publicKey.verifyAddress(keypair.toSuiAddress())) {
 will throw an error if the signature is not valid for the provided address.
 
 ```typescript
+
 const keypair = new Ed25519Keypair();
 const message = new TextEncoder().encode('hello world');
 const { signature } = await keypair.signPersonalMessage(message);
@@ -131,12 +134,13 @@ await verifyTransactionSignature(bytes, signature, {
 ## Verifying zkLogin signatures
 
 ZkLogin signatures can't be verified purely on the client. When verifying a zkLogin signature, the
-SDK uses the GraphQL API to verify the signature. This will work for mainnet signatures without any
+SDK uses the GraphQL API to verify the signature. This works for Mainnet signatures without any
 additional configuration.
 
-For testnet signatures, you will need to provide a testnet GraphQL Client:
+For Testnet signatures, you need to provide a Testnet GraphQL Client:
 
 ```typescript
+
 const publicKey = await verifyPersonalMessageSignature(message, zkSignature, {
 	client: new SuiGraphQLClient({
 		url: 'https://graphql.testnet.sui.io/graphql',
@@ -144,14 +148,15 @@ const publicKey = await verifyPersonalMessageSignature(message, zkSignature, {
 });
 ```
 
-For some zklogin accounts, there are 2 valid addresses for a given set of inputs. This means you may
-run into issues if you try to compare the address returned by `publicKey.toSuiAddress()` directly
-with an expected address.
+For some zklogin accounts, there are two valid addresses for a given set of inputs. This means you
+might run into issues if you try to compare the address returned by `publicKey.toSuiAddress()`
+directly with an expected address.
 
 Instead, you can either pass in the expected address during verification, or use the
 `publicKey.verifyAddress(address)` method:
 
 ```typescript
+
 const publicKey = await verifyPersonalMessageSignature(message, zkSignature, {
 	client: new SuiGraphQLClient({
 		url: 'https://graphql.testnet.sui.io/graphql',
@@ -186,6 +191,7 @@ If you know the Keypair scheme for your secret key, you can use the `fromSecretK
 appropriate `Keypair` class to derive the keypair from the secret key.
 
 ```typescript
+
 // Example bech32 encoded secret key (which always starts with 'suiprivkey')
 const secretKey = 'suiprivkey1qzse89atw7d3zum8ujep76d2cxmgduyuast0y9fu23xcl0mpafgkktllhyc';
 
@@ -197,6 +203,7 @@ keyScheme, and get the keypairs private key bytes, which can be used to instanti
 `Keypair` class.
 
 ```typescript
+
 const { scheme, secretKey } = decodeSuiPrivateKey(encoded);
 
 // use scheme to choose the correct key pair
@@ -237,6 +244,7 @@ If you have only the raw private key bytes for your keypair, you can encode to t
 using the `encodeSuiPrivateKey` function.
 
 ```typescript
+
 const encoded = encodeSuiPrivateKey(
 	new Uint8Array([
 		59, 148, 11, 85, 134, 130, 61, 253, 2, 174, 59, 70, 27, 180, 51, 107, 94, 203, 174, 253, 102,
@@ -253,6 +261,7 @@ converting the secret key to a `Uint8Array` and passing it to the `fromSecretKey
 `Keypair` class.
 
 ```typescript
+
 const secret = '0x...';
 const keypair = Ed25519Keypair.fromSecretKey(fromHex(secret));
-```
+```

package/docs/cryptography/multisig.md

@@ -1,6 +1,6 @@
 # Multi-Signature Transactions
 
-> Create multi-signature transactions with multiple signers
+> Create multi-signature transactions with multiple signers on Sui.
 
 The Sui TypeScript SDK provides a `MultiSigPublicKey` class to support
 [Multi-Signature](https://docs.sui.io/concepts/cryptography/transaction-auth/multisig) (MultiSig)
@@ -17,6 +17,7 @@ transaction is equal to or greater than the threshold value, then the Sui networ
 transdaction valid.
 
 ```typescript
+
 const kp1 = new Ed25519Keypair();
 const kp2 = new Ed25519Keypair();
 const kp3 = new Ed25519Keypair();
@@ -68,13 +69,14 @@ const isValid = await multiSigPublicKey.verifyPersonalMessage(message, combinedS
 
 The `MultiSigSigner` class allows you to create a Signer that can be used to sign personal messages
 and Transactions like any other keypair or signer class. This is often easier than manually
-combining signatures, since many methods accept Signers and handle signing directly.
+combining signatures, because many methods accept Signers and handle signing directly.
 
 A `MultiSigSigner` is created by providing the underlying Signers to the `getSigner` method on the
 `MultiSigPublicKey`. You can provide a subset of the Signers that make up the public key, so long as
 their combined weight is equal to or greater than the threshold.
 
 ```typescript
+
 const kp1 = new Ed25519Keypair();
 const kp2 = new Ed25519Keypair();
 
@@ -145,7 +147,7 @@ const zkLoginSig = getZkLoginSignature({
 const multisig = multiSigPublicKey.combinePartialSignatures([zkLoginSig]);
 ```
 
-### Benefits and Design for zkLogin in Multisig
+### Benefits and design for zkLogin in multisig
 
 Because zkLogin assumes the application client ID and its issuer (such as Google) liveliness, using
 zkLogin with multisig provides improved recoverability to a zkLogin account. In the previous example
@@ -166,7 +168,7 @@ In this case, Charlie can always use their Google account for transactions out o
 address for the threshold. At the same time, Charlie still has access to his account by combining
 partial signatures from Alice and Bob.
 
-## Multisig with Passkey
+## Multisig with passkey
 
 You can use a `PasskeyKeypair` (a `Keypair`) and `PasskeyPublicKey` (a `PublicKey`) as components in
 a Multisig setup. Once initialized, they support both Multisig address derivation and transaction
@@ -189,4 +191,4 @@ const multiSigPublicKey = MultiSigPublicKey.fromPublicKeys({
 		// other keys
 	],
 });
-```
+```

package/docs/cryptography/passkey.md

@@ -1,6 +1,6 @@
 # Passkey
 
-> Use WebAuthn passkeys for Sui transaction signing
+> Use WebAuthn passkeys for Sui transaction signing.
 
 Similar to other Keypair classes, the Sui TypeScript SDK provides the `PasskeyKeypair` that handles
 communication with the passkey device and signing with it. This SDK defines the address and
@@ -19,8 +19,8 @@ To use, import the `PasskeyKeypair` class from `@mysten/sui/keypairs/passkey`.
 ## Create a new passkey
 
 To create a new passkey with the passkey device, and initialize a `PasskeyKeypair`, you can use the
-`PasskeyProvider` and provide the `rpName`, `rpId` and additional options. Note that
-`getPasskeyInstance` call will initialize a new passkey wallet for the origin.
+`PasskeyProvider` and provide the `rpName`, `rpId`, and additional options. The `getPasskeyInstance`
+call initializes a new passkey wallet for the origin.
 
 ```typescript
 const keypair = await PasskeyKeypair.getPasskeyInstance(
@@ -49,15 +49,15 @@ same instance and the public key is available when constructing the passkey sign
 It is recommended that the user should only be allowed to create a passkey wallet once per origin.
 If the user ended up with multiple passkeys for the same origin, the passkey UI would show a list of
 all passkeys of the same origin and the user can choose which one to use. This can be a confusing
-experience since they do not remember which passkey is the way that the wallet was created for.
+experience because they do not remember which passkey is the way that the wallet was created for.
 
 ## Recover a passkey
 
 However, if the user is logged out or uses a different browser or device, or the `PasskeyKeypair`
-instance is no longer present for any reason, the user should be prompt to recover the public key
-(e.g. "Log in to existing passkey wallet") to be able to use the passkey wallet again. If the user
-is prompted to create a new key in passkey device, a fresh new wallet with new address will be
-created.
+instance is no longer present for any reason, the user should be prompted to recover the public key
+(for example, through a "Log in to existing passkey wallet" flow) to be able to use the passkey
+wallet again. If the user is prompted to create a new key in passkey device, a fresh new wallet with
+new address will be created.
 
 One can recover the unique public key with exactly two passkey signatures on two messages. This
 means that if the user is asked to sign two messages, the developer can recover an unique public key
@@ -80,15 +80,16 @@ const keypair = new PasskeyKeypair(commonPk.toRawBytes(), provider);
 ```
 
 Alternatively, the developer can choose to ask the user to only sign one personal message that
-returns two possible public keys. Then the frontend may derive the addresses for both, and check
-onchain for the unique address that contains assets. Or the frontend may retrieve additional
-signatures from past transaction history for the given address. This may a preferred user experience
-since the user is only prompted to sign one message, but the frontend needs to do extra work.
+returns two possible public keys. Then the frontend might derive the addresses for both and check
+onchain for the unique address that contains assets. Or the frontend might retrieve additional
+signatures from past transaction history for the given address. This might be a preferred user
+experience because the user is only prompted to sign one message, but the frontend needs to do extra
+work.
 
 ## Usage
 
 The usage for a passkey keypair is the same as any other keypair. You can derive the public key,
-derive the address, sign personal messages, sign transactions and verify signatures. See the
+derive the address, sign personal messages, sign transactions, and verify signatures. See the
 [Key pairs](./keypairs) documentation for more details.
 
 ```typescript
@@ -103,9 +104,9 @@ const txSignature = await passkey.signTransaction(txBytes);
 
 An example implemention can be found [here](https://github.com/MystenLabs/passkey-example).
 
-## Supported Platforms
+## Supported platforms
 
 Sui supports passkey wallets on any device that complies with the WebAuthn standard. This includes
 most modern browsers and operating systems across desktop and mobile. To check which platforms and
 authenticators are compatible, see the
-[Passkeys.dev device support list](https://passkeys.dev/device-support/).
+[Passkeys.dev device support list](https://passkeys.dev/device-support/).

package/docs/cryptography/webcrypto-signer.md

@@ -1,9 +1,9 @@
 # Web Crypto Signer
 
-> Sign transactions using the Web Crypto API
+> Sign transactions using the Web Crypto API for secure browser-based key management.
 
-For cases where you need to create keypairs directly within client dapps, we recommend using the Web
-Crypto Signer. This signer leverages the
+For cases where you need to create keypairs directly within client apps, you can use the Web Crypto
+Signer. This signer leverages the
 [Web Crypto API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API) to provide a
 secure and efficient way to generate and manage cryptographic keys in the browser. The generated
 keys are `Secp256r1` keys which can be persisted between sessions, and are not extractable by
@@ -16,10 +16,10 @@ Common use cases for the Web Crypto Signer include:
 
 ## Installation
 
-To use the Web Crypto Signer, you need to install the `@mysten/signers` package.
+To use the Web Crypto Signer, you need to install the `@mysten/webcrypto-signer` package.
 
 ```sh npm2yarn
-npm i @mysten/signers
+npm i @mysten/webcrypto-signer
 ```
 
 You can then import the `WebCryptoSigner` class from the package:
@@ -62,13 +62,13 @@ const exported = await readFromIndexedDB('keypair');
 const keypair = await WebCryptoSigner.import(exported);
 ```
 
-> **Warning:** Ensure that you do not call `JSON.stringify` on the exported keypair before
-> persisting it to IndexedDB, as it will throw an error and fail to persist.
+> **Warning:** Ensure that you do not call `JSON.stringify` on the exported keypair before persisting it to
+> IndexedDB, as it will throw an error and fail to persist.
 
 ## Usage
 
 The usage for a Web Crypto signer is the same as any other keypair. You can derive the public key,
-derive the address, sign personal messages, sign transactions and verify signatures. See the
+derive the address, sign personal messages, sign transactions, and verify signatures. See the
 [Key pairs](./keypairs) documentation for more details.
 
 ```typescript
@@ -78,4 +78,4 @@ const address = publicKey.toSuiAddress();
 const message = new TextEncoder().encode('hello world');
 await keypair.signPersonalMessage(message);
 await keypair.signTransaction(txBytes);
-```
+```

package/docs/executors.md

@@ -1,15 +1,16 @@
 # Transaction Executors
 
-> Manage transaction execution with queuing and parallel strategies
+> 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.
+The TypeScript SDK ships two `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
+The `SerialTransactionExecutor` is designed for use in wallet implementations and apps where the
 objects owned by the address executing transactions are unlikely to be changed by transactions not
 executed through the executor.
 
@@ -35,6 +36,7 @@ transactions to finish before sending the next one.
   from the sender's address balance.
 
 ```ts
+
 const client = new SuiGrpcClient({
 	network: 'devnet',
 	baseUrl: 'https://fullnode.devnet.sui.io:443',
@@ -60,8 +62,7 @@ const [{ digest: digest1 }, { digest: digest2 }] = await Promise.all([
 
 ## `ParallelTransactionExecutor`
 
-> **Warning:** `ParallelTransactionExecutor` is experimental and may change rapidly as it is being
-> developed.
+> **Warning:** `ParallelTransactionExecutor` is experimental and might 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`
@@ -69,10 +70,10 @@ will maintain a pool of gas coins, and automatically execute additional transact
 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
+> `ParallelTransactionExecutor` is in use might consume or combine gas coins in the gasPool, causing
+> transactions to fail. This might 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.
 
@@ -99,11 +100,13 @@ way that avoids conflicts between transactions using the same object ids.
   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`)
+- `epochBoundaryWindow`: Time to wait before or 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({
@@ -124,24 +127,24 @@ const [{ digest: digest1 }, { digest: digest2 }] = await Promise.all([
 ]);
 ```
 
-## Building and Executing Transactions with Executors
+## 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
+full `id`, `version`, and `digest` for an object input (for example, 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
+If the signer executes transactions that are not sent through the executor, that might 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.
+> **Warning:** Transaction plugins and intents might 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

@@ -1,6 +1,6 @@
 # Faucet
 
-> Request test SUI tokens from the 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.
@@ -21,6 +21,6 @@ await requestSuiFromFaucetV2({
 });
 ```
 
-> **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`.
+> **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,6 +1,6 @@
 # Hello Sui
 
-> Build your first Sui application with the TypeScript SDK
+> 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
@@ -9,8 +9,8 @@ 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
+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
@@ -55,6 +55,7 @@ address. You must be on Devnet, Testnet, or a local network to use a faucet for
 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>';
 
@@ -106,9 +107,9 @@ that it uses to query the address and output the amount of SUI the address owns
 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`.
+> **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.
+calls on a Sui network.