@haneullabs/haneul 2.5.2 → 2.13.0

package/docs/executors.md

@@ -0,0 +1,148 @@
+# 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 HANEUL 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 Haneul client (such as `HaneulGrpcClient`) 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 HaneulGrpcClient({
+	network: 'devnet',
+	baseUrl: 'https://fullnode.devnet.haneul.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 `HaneulJsonRpcClient` 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 GEUNHWA (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 HaneulJsonRpcClient({ 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 HANEUL or the required
+> balances are available as address balances rather than coin objects.

package/docs/faucet.md

@@ -0,0 +1,26 @@
+# Faucet
+
+> Request test HANEUL tokens from the faucet
+
+Devnet, Testnet, and local networks include faucets that mint HANEUL. You can use the Haneul
+TypeScript SDK to call a network's faucet and provide HANEUL to the address you provide.
+
+To request HANEUL from a faucet, import the `requestHaneulFromFaucetV2` function from the
+`@haneullabs/haneul/faucet` package to your project.
+
+```typescript
+
+```
+
+Use `requestHaneulFromFaucetV2` in your TypeScript code to request HANEUL from the network's faucet.
+
+```typescript
+await requestHaneulFromFaucetV2({
+	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
+> HANEUL is via the Web UI: `faucet.haneul.io`.

package/docs/hello-haneul.md

@@ -0,0 +1,115 @@
+# Hello Haneul
+
+> Build your first Haneul application with the TypeScript SDK
+
+This basic example introduces you to the Haneul TypeScript SDK. The Node.js example mints HANEUL on
+a Haneul network and then queries the address to get a sum for the owned HANEUL. 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 Haneul development network (Devnet, Testnet, local). If you don't already
+have an address, use the [Haneul Client CLI](https://docs.haneul.io/references/cli/client) or the
+[Haneul Wallet browser extension](https://docs.haneul-labs.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-haneul` in this example) and
+make it the working directory.
+
+```sh
+mkdir hello-haneul
+cd hello-haneul
+```
+
+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 Haneul TypeScript SDK:
+
+```sh npm2yarn
+npm i -D @haneullabs/haneul
+```
+
+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": {
+		"@haneullabs/haneul": "^<VERSION_NUMBER>"
+	}
+}
+```
+
+## Get some HANEUL for your account
+
+Instead of a 'Hello World' output to your console, this example introduces some HANEUL to your
+wallet address. You must be on Devnet, Testnet, or a local network to use a faucet for minting
+HANEUL.
+
+Create a new `index.js` file in the root of your project with the following code.
+
+```js
+// replace <YOUR_HANEUL_ADDRESS> with your actual address, which is in the form 0x123...
+const MY_ADDRESS = '<YOUR_HANEUL_ADDRESS>';
+
+// create a new HaneulGrpcClient object pointing to the network you want to use
+const haneulClient = new HaneulGrpcClient({
+	network: 'devnet',
+	baseUrl: 'https://fullnode.devnet.haneul.io:443',
+});
+
+// Convert GEUNHWA to Haneul
+const balance = (balance) => {
+	return Number.parseInt(balance.totalBalance) / Number(GEUNHWA_PER_HANEUL);
+};
+
+// store the JSON representation for the HANEUL the address owns before using faucet
+const haneulBefore = await haneulClient.getBalance({
+	owner: MY_ADDRESS,
+});
+
+await requestHaneulFromFaucetV2({
+	// use getFaucetHost to make sure you're using correct faucet address
+	// you can also just use the address (see Haneul TypeScript SDK Quick Start for values)
+	host: getFaucetHost('devnet'),
+	recipient: MY_ADDRESS,
+});
+
+// store the JSON representation for the HANEUL the address owns after using faucet
+const haneulAfter = await haneulClient.getBalance({
+	owner: MY_ADDRESS,
+});
+
+// Output result to console.
+console.log(
+	`Balance before faucet: ${balance(haneulBefore)} HANEUL. Balance after: ${balance(
+		haneulAfter,
+	)} HANEUL. Hello, HANEUL!`,
+);
+```
+
+Save the file, then use Node.js to run it in your Console or Terminal:
+
+```sh
+node index.js
+```
+
+The code imports the `requestHaneulFromFaucetV2` function from the SDK and calls it to mint HANEUL
+for the provided address. The code also imports `HaneulGrpcClient` to create a new client on the
+Haneul network that it uses to query the address and output the amount of HANEUL the address owns
+before and after using the faucet. You can check the total HANEUL for your address using the Haneul
+Wallet or Haneul 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
+> HANEUL is via the Web UI: `faucet.haneul.io`.
+
+You can also use the [Haneul Client CLI](https://docs.haneul.io/references/cli/client) to perform
+client calls on a Haneul network.

package/docs/index.md

@@ -0,0 +1,56 @@
+# Haneul TypeScript SDK Quick Start
+
+> TypeScript SDK for building on the Haneul blockchain
+
+The Haneul TypeScript SDK is a modular library of tools for interacting with the Haneul blockchain.
+Use it to send queries to RPC nodes, build and sign transactions, and interact with a Haneul or
+local network.
+
+## Installation
+
+```sh npm2yarn
+npm i @haneullabs/haneul
+```
+
+## Network locations
+
+The following table lists the locations for Haneul 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.haneul.io:443`  | `https://faucet.devnet.haneul.io/v2/gas`  |
+| Testnet | `https://fullnode.testnet.haneul.io:443` | `https://faucet.testnet.haneul.io/v2/gas` |
+| Mainnet | `https://fullnode.mainnet.haneul.io:443` | `null`                                    |
+
+> **Warning:** Use dedicated nodes/shared services rather than public endpoints for production apps.
+> The public endpoints maintained by Haneul Labs (`fullnode.<NETWORK>.haneul.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 Haneul on the [Haneul Dev Portal](https://haneul.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.
+
+- [`@haneullabs/haneul/client`](/haneul/clients) - A client for interacting with Haneul RPC nodes.
+- [`@haneullabs/haneul/bcs`](/haneul/bcs) - A BCS builder with pre-defined types for Haneul.
+- [`@haneullabs/haneul/transactions`](/haneul/transaction-building/basics) - Utilities for building
+  and interacting with transactions.
+- [`@haneullabs/haneul/keypairs/*`](/haneul/cryptography/keypairs) - Modular exports for specific
+  KeyPair implementations.
+- [`@haneullabs/haneul/verify`](/haneul/cryptography/keypairs#verifying-signatures-without-a-key-pair) -
+  Methods for verifying transactions and messages.
+- [`@haneullabs/haneul/cryptography`](/haneul/cryptography/keypairs) - Shared types and classes for
+  cryptography.
+- [`@haneullabs/haneul/multisig`](/haneul/cryptography/multisig) - Utilities for working with
+  multisig signatures.
+- [`@haneullabs/haneul/utils`](/haneul/utils) - Utilities for formatting and parsing various Haneul
+  types.
+- [`@haneullabs/haneul/faucet`](/haneul/faucet) - Methods for requesting HANEUL from a faucet.
+- [`@haneullabs/haneul/zklogin`](/haneul/zklogin) - Utilities for working with zkLogin.

package/docs/install.md

@@ -0,0 +1,61 @@
+# Install Haneul TypeScript SDK
+
+> Install the @haneullabs/haneul package and configure your project
+
+The Haneul TypeScript SDK is available in the
+[Haneul TS SDK monorepo](https://github.com/GeunhwaJeong/ts-sdks) and NPM.
+
+## Install from NPM
+
+To use the Haneul TypeScript SDK in your project, run the following command in your project root:
+
+```sh npm2yarn
+npm i @haneullabs/haneul
+```
+
+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](/haneul/migrations/haneul-2.0#esm-migration) for more details.
+
+## Experimental tag for use with a local Haneul network
+
+Projects developing against one of the on-chain Haneul 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.haneul.io/guides/developer/getting-started/local-network) built from
+the `main` branch of the Haneul 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 @haneullabs/haneul@experimental
+```
+
+## Install from local build
+
+To build the SDK from the Haneul monorepo, you must use [pnpm](https://pnpm.io/). With pnpm
+installed, run the following command from the `haneul` 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 `haneul` project. To do so, use a path to
+the `ts-sdks/packages/haneul` directory that is relative to your project. For example, if you
+created a folder `my-haneul-project` at the same level as `haneul`, use the following to import the
+locally built Haneul TypeScript package:
+
+```bash
+pnpm add ../ts-sdks/packages/haneul
+```

package/docs/llm-docs.md

@@ -0,0 +1,32 @@
+# LLM Documentation
+
+> Give AI agents access to Haneul SDK documentation in your project
+
+Every `@haneullabs/*` 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 `@haneullabs/haneul` gives you docs at
+`node_modules/@haneullabs/haneul/docs/llms-index.md`.
+
+## Configure Your Agent
+
+Add the following snippet to your agent's configuration file (`AGENTS.md`, `CLAUDE.md`,
+`.cursorrules`, etc.):
+
+```markdown
+## Haneul SDK Reference
+
+Every @haneullabs/\* 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/@haneullabs/\*/`. Read the index first to find the page you need, then read that page
+for details.
+```

package/docs/llms-index.md

@@ -0,0 +1,66 @@
+# Haneul SDK
+
+> TypeScript interfaces for Haneul
+
+- [Haneul TypeScript SDK Quick Start](./index.md): TypeScript SDK for building on the Haneul
+  blockchain
+- [Install Haneul TypeScript SDK](./install.md): Install the @haneullabs/haneul package and
+  configure your project
+- [LLM Documentation](./llm-docs.md): Give AI agents access to Haneul SDK documentation in your
+  project
+- [Hello Haneul](./hello-haneul.md): Build your first Haneul application with the TypeScript SDK
+- [Faucet](./faucet.md): Request test HANEUL tokens from the faucet
+- [Haneul 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 Haneul clients
+- [HaneulGrpcClient](./clients/grpc.md): Connect to Haneul via gRPC with HaneulGrpcClient
+- [HaneulGraphQLClient](./clients/graphql.md): Connect to Haneul via GraphQL with
+  HaneulGraphQLClient
+- [HaneulJsonRpcClient](./clients/json-rpc.md): Connect to Haneul via JSON-RPC with
+  HaneulJsonRpcClient
+- [Haneul Programmable Transaction Basics](./transaction-building/basics.md): Construct programmable
+  transaction blocks with the Transaction API
+- [Paying for Haneul 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 Haneul transaction signing
+- [Web Crypto Signer](./cryptography/webcrypto-signer.md): Sign transactions using the Web Crypto
+  API
+- [The `@haneullabs/haneul/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 Haneul Move types
+- [ZkLogin](./zklogin.md): Zero-knowledge authentication with OAuth providers on Haneul
+- [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 Haneul TypeScript SDK
+- [Migrate to 2.0](./migrations/haneul-2.0/index.md): Migration guide for Haneul TypeScript SDK 2.0
+- [Agent Migration Prompt](./migrations/haneul-2.0/agent-prompt.md): AI agent prompt for automated
+  SDK 2.0 migration
+- [@haneullabs/haneul](./migrations/haneul-2.0/haneul.md): Migrate @haneullabs/haneul from 1.x to
+  2.0
+- [Migrating from JSON-RPC](./migrations/haneul-2.0/json-rpc-migration.md): Migrate from JSON-RPC to
+  the new Core API
+- [@haneullabs/dapp-kit](./migrations/haneul-2.0/dapp-kit.md): Migrate @haneullabs/dapp-kit to 2.0
+- [@haneullabs/kiosk](./migrations/haneul-2.0/kiosk.md): Migrate @haneullabs/kiosk to 2.0
+- [@haneullabs/zksend](./migrations/haneul-2.0/zksend.md): Migrate @haneullabs/zksend to 2.0
+- [@haneullabs/haneulns](./migrations/haneul-2.0/haneulns.md): Migrate @haneullabs/haneulns to 2.0
+- [@haneullabs/deepbook-v3](./migrations/haneul-2.0/deepbook-v3.md): Migrate @haneullabs/deepbook-v3
+  to 2.0
+- [@haneullabs/walrus](./migrations/haneul-2.0/walrus.md): Migrate @haneullabs/walrus to 2.0
+- [@haneullabs/seal](./migrations/haneul-2.0/seal.md): Migrate @haneullabs/seal to 2.0
+- [Wallet Builders](./migrations/haneul-2.0/wallet-builders.md): Migration guide for wallet
+  extension developers
+- [SDK Maintainers](./migrations/haneul-2.0/sdk-maintainers.md): Migration guide for SDK maintainers
+  and library authors
+- [Migrate to 1.0](./migrations/haneul-1.0.md): Migrate to Haneul 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 Haneul 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 Haneul 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 Haneul TypeScript SDK deprecates the following classes with version 0.38.0:
+
+- `JsonRpcProvider` - The `JsonRpcProvider` class is deprecated in favor of the `haneulClient` class
+  when creating a client for a Haneul network. See
+  [Network Interactions with HaneulJsonRpcClient](/haneul/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](/haneul/cryptography/keypairs)
+  topic for more information.
+- `signAndExecuteTransaction` - This method was not deprecated, but is now part of
+  `HaneulJsonRpcClient`.
+- `Connection` classes - The `Connection` classes (`Connection`, `devnetConnection`, and so on) have
+  been deprecated in favor ofHaneulJsonRpcClientuiClient` for establishing the connection. See
+  [Network Interactions with HaneulJsonRpcClient](/haneul/clients) for more information.
+- The `superstruct` type definitions for `JsonRPCProvider` types are replaced with generated types
+  exported from `@haneullabs/haneul/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
+[Haneul Programmable Transaction Blocks Basics](/haneul/transaction-building/basics) topic.
+
+### Faucet requests
+
+HaneulJsonRpcClient The ability to request HANEUL from a faucet is not part of `HaneulJsonRpcClient`
+as it was with `JsonRpcProvider`. Instead, you must use the `requestHaneulFromFaucetV0` method from
+`@haneullabs/haneul/faucet`. The `@haneullabs/haneul/faucet` import also provides a `getFaucetHost`
+method to retrieve the faucet URL for `localnet`, `testnet`, or `devnet` networks.
+
+```ts
+await requestHaneulFromFaucetV0({
+	host: getFaucetHost('devnet'),
+	recipient: '<HANEUL_ADDRESS>',
+});
+```