@quicknode/sdk 3.6.0 → 3.8.0

package/README.md

@@ -11,8 +11,12 @@ This is one of four language bindings published from the same Rust core. See the
 - [Installation](#installation)
 - [Quick Start](#quick-start)
 - [Configuration](#configuration)
+  - [Option A — Pass config directly](#option-a--pass-config-directly)
+  - [Option B — Load from environment (`from_env()`)](#option-b--load-from-environment-from_env)
+  - [Custom headers and `User-Agent`](#custom-headers-and-user-agent)
 - [Platform Support](#platform-support)
 - [API Reference](#api-reference)
+  - [Language conventions](#language-conventions)
   - [Admin Client](#admin-client)
     - [Endpoints](#endpoints)
     - [Endpoint Tags](#endpoint-tags)
@@ -48,6 +52,12 @@ This is one of four language bindings published from the same Rust core. See the
     - [Sets](#sets)
     - [Lists](#lists)
   - [SQL Client](#sql-client)
+  - [RPC & Tooling Access](#rpc--tooling-access)
+- [Crypto-micropayment lane (`rpc.call`)](#crypto-micropayment-lane-rpccall)
+  - [Wallet generation](#wallet-generation)
+  - [x402 credit drawdown (authenticate once, then draw one credit per call)](#x402-credit-drawdown-authenticate-once-then-draw-one-credit-per-call)
+    - [Testnet faucet](#testnet-faucet)
+  - [MPP payment channel (deposit once, then vouchers)](#mpp-payment-channel-deposit-once-then-vouchers)
 - [Error Handling](#error-handling)
 - [License](#license)
 
@@ -78,6 +88,10 @@ There are two ways to configure the SDK.
 // Node.js
 import { QuicknodeSdk } from "quicknode-sdk";
 const qn = new QuicknodeSdk({ apiKey: "your-key", http: { timeoutSecs: 30 } });
+
+// apiKey is optional: the crypto-micropayment lane pays per request instead, so
+// omitting it builds a usable SDK. Every other client still needs one, and
+// fromEnv() always requires QN_SDK__API_KEY.
 ```
 
 ### Option B — Load from environment (`from_env()`)
@@ -1674,6 +1688,222 @@ const schema = await qn.sql.getSchema("hyperliquid-core-mainnet");
 console.log(schema.tables.length);
 ```
 
+---
+
+### RPC & Tooling Access
+
+Tooling Access provisions a single multichain, read-only endpoint per account and
+mints short-lived session JWTs. `qn.rpc` makes JSON-RPC calls directly against that
+endpoint, minting and refreshing the JWT automatically — no endpoint URL or token to
+manage.
+
+Tooling Access must be enabled once (admin role + eligible plan). The control-plane
+methods live on `qn.admin`:
+
+```typescript
+// Node.js
+const status = await qn.admin.toolingAccessStatus();
+if (!status.enabled) {
+  await qn.admin.enableToolingAccess(); // idempotent; admin role required
+}
+
+// Make on-chain calls. params defaults to []; pass an array (positional) or object.
+const blockNumber = await qn.rpc.call("eth_blockNumber");
+const balance = await qn.rpc.call("eth_getBalance", ["0xabc...", "latest"]);
+
+// Multichain: select a network by its multichain_urls key. Seed the map first
+// (from admin.getEndpointUrls), then pass the network as the 3rd arg.
+const urls = await qn.admin.getEndpointUrls(endpointId);
+const map = Object.fromEntries(
+  Object.entries(urls.multichainUrls ?? {}).map(([k, v]) => [k, v.httpUrl]),
+);
+qn.rpc.setNetworks(map);
+const slot = await qn.rpc.call("getSlot", [], "solana-mainnet");
+
+// Custom endpoint URL: send to a fully-formed HTTP URL, bypassing Tooling Access
+// and the JWT (no Authorization header). Per-call via the 4th arg, or client-wide
+// via `new RpcConfig({ endpointUrl })`. endpointUrl and network are mutually
+// exclusive (a custom URL is not multichain-routed).
+const block = await qn.rpc.call("eth_blockNumber", [], undefined, "https://my-endpoint.example/rpc");
+
+// A JSON-RPC error member is thrown as RpcError (with .code and .message).
+import { RpcError } from "@quicknode/sdk";
+try {
+  await qn.rpc.call("eth_getBalance", ["bad"]);
+} catch (e) {
+  if (e instanceof RpcError) console.error(e.code, e.message);
+}
+```
+
+A host that persists across processes can snapshot the cached token with
+`qn.rpc.currentToken()` and re-seed it via `RpcConfig.seed` on the next construction;
+`refreshMarginSecs` (default 60) tunes how early the token is refreshed. Set
+`RpcConfig.endpointUrl` to route every call to a custom HTTP URL by default (no
+JWT minted); a per-call `endpointUrl` overrides it.
+
+## Crypto-micropayment lane (`rpc.call`)
+
+Pay per RPC request with a stablecoin instead of a provisioned account + API key,
+against Quicknode's `x402.quicknode.com` and `mpp.quicknode.com` gateways. Configure
+it by setting `payment` on the RPC config; the SDK runs the `402` → sign → resend
+handshake for you. An API key is **not** required for this lane — build a keyless SDK.
+
+There are four payment paths. Two pay per request; two amortize one signature over many
+calls.
+
+| Path | Entry point | Gateway | Signs |
+|---|---|---|---|
+| Per-request x402 | `call` / `callWithReceipt` with `scheme: "x402"` | x402 | once per call |
+| Per-request MPP charge | `call` / `callWithReceipt` with `scheme: "mpp"` | mpp | once per call |
+| [x402 credit drawdown](#x402-credit-drawdown-authenticate-once-then-draw-one-credit-per-call) | `gatewayAuthenticate` → `gatewayDrawdownCall` | x402 | once per session |
+| [MPP payment channel](#mpp-payment-channel-deposit-once-then-vouchers) | `mppOpen` → `mppSessionCall` | mpp | once per channel |
+
+The signer construction is derived from the scheme and pay network, never stated directly:
+**x402/EVM** signs an EIP-712 `TransferWithAuthorization`, **x402/Solana** an SPL
+`TransferChecked` in a v0 tx (the gateway sponsors gas), and **MPP/Tempo** a native Tempo
+transaction.
+
+`scheme` selects the gateway for `call` only. The `gateway*` drawdown methods always use
+the x402 gateway and the `mpp*` channel methods always use the MPP gateway, whatever
+`scheme` is set to.
+
+`PaymentConfig` fields:
+
+| Field | Meaning |
+|---|---|
+| `scheme` | `"x402"` (pay-per-request) or `"mpp"` (MPP charge; `"mpp-charge"` is accepted too) |
+| `key` | raw private key — EVM/Tempo: hex; Solana: base58 64-byte secret |
+| `payNetwork` | CAIP-2 pay network, e.g. `eip155:84532`, `solana:5eykt4…` |
+| `asset` | token address/mint to pay in (matches the offered menu entry) |
+| `maxAmount` | **required** spend ceiling in integer base units of `asset` |
+| `svmRpcUrl` | optional Solana RPC for x402/Solana payment-build reads (mint + blockhash) |
+| `baseUrlOverride` | optional gateway base (testing) |
+
+`network` on the call is the **query** chain (gateway path slug), independent of the
+pay network. Use `callWithReceipt` to also get the settlement receipt (`reference` =
+settlement tx hash) — populated on the MPP lane, `null` for x402.
+
+**Things to know:**
+
+- **Do not log your own `PaymentConfig`** — the `key` field is readable. The SDK
+  never prints it in its own errors, but `console.log(config)` will show it.
+- **`maxAmount` is integer base units of the selected asset.** The SDK skips any offered
+  entry above it and refuses to sign one — a guard against an overcharging gateway.
+- **`PaymentIndeterminateError` means the paid request was sent but the response was lost.**
+  You MAY have been charged — do **not** blindly retry.
+- **x402/Solana: one payment per call.** Building a payment reads the mint and a recent
+  blockhash from a Solana RPC. The default is a public RPC that **rate-limits
+  aggressively** — set `svmRpcUrl` to your own endpoint at any volume.
+
+```typescript
+import { QuicknodeSdk } from "@quicknode/sdk";
+
+const qn = new QuicknodeSdk({
+  rpc: {
+    payment: {
+      scheme: "x402",
+      key: process.env.QN_PAYMENT_KEY!,
+      payNetwork: "eip155:84532",
+      asset: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+      maxAmount: "10000",
+    },
+  },
+});
+const { result, paymentReceipt } = await qn.rpc.callWithReceipt("eth_blockNumber", [], "base-sepolia");
+console.log(result, paymentReceipt);
+```
+
+### Wallet generation
+
+`generatePaymentWallet("evm")` creates a fresh keypair offline — no network call, no funds — for
+`"evm"`, `"svm"`, or `"tempo"`. The private key is returned **exactly once**, at
+generation; nothing in the SDK stores or re-derives it, so persist it immediately.
+
+```typescript
+import { generatePaymentWallet } from "@quicknode/sdk";
+
+const wallet = generatePaymentWallet("evm");
+console.log("fund this address:", wallet.address);
+// wallet.key is returned exactly once — persist it now.
+```
+
+### x402 credit drawdown (authenticate once, then draw one credit per call)
+
+Cheaper per call than paying per request: one SIWE signature mints a session JWT, then
+each call draws a single credit from the account balance instead of signing a fresh
+settlement. Minting the session is free and moves no funds, so a host can re-authenticate
+transparently. Persist it between processes.
+
+Fund the payment wallet out of band — the testnet faucet below, or by sending funds to
+`paymentAddress()` directly. Credits are provisioned against the account gateway-side.
+
+EVM signers only: SIWE is an EIP-4361 construction, so an x402/Solana key errors here.
+
+| Method | Cost | Returns |
+|---|---|---|
+| `paymentAddress()` | free, offline | the wallet address derived from the key |
+| `gatewayAuthenticate()` | free | `GatewaySession { token, expUnix, accountId }` |
+| `gatewayCredits(session)` | free | `CreditBalance { accountId, credits }` |
+| `gatewayDrip(session)` | free (testnet) | `DripReceipt { accountId, transactionHash }` |
+| `gatewayDrawdownCall(method, session, network, params?)` | 1 credit | the JSON-RPC `result` |
+
+```typescript
+const session = await qn.rpc.gatewayAuthenticate();
+const balance = await qn.rpc.gatewayCredits(session);
+console.log("credits:", balance.credits);
+const result = await qn.rpc.gatewayDrawdownCall("eth_blockNumber", session, "base-sepolia");
+```
+
+A `token_expired` surfaces as an `ApiError` with status 401/403; re-authenticate and retry
+that call.
+
+#### Testnet faucet
+
+`gatewayDrip` requests testnet tokens for the payment **wallet** on Base Sepolia. The
+gateway allows one drip per account, and it returns the on-chain funding transaction hash
+— not a credit balance.
+
+### MPP payment channel (deposit once, then vouchers)
+
+Open a payment channel by depositing into the escrow, then authorize each call with a
+cumulative voucher — one `ecrecover` server-side, no on-chain transaction per call.
+
+| Method | Cost | Returns |
+|---|---|---|
+| `mppOpen(deposit)` | **moves funds** | `ChannelState` — persist it |
+| `mppTopUp(channel, additionalDeposit)` | **moves funds** | the updated channel state |
+| `mppStatus(channel)` | **1 request unit** | `ChannelStatus { channelId, acceptedCumulative, spent }` |
+| `mppSessionCall(method, network, channel, newCumulative, params?)` | 1 request unit | the JSON-RPC `result` |
+| `mppClose(channel)` | settles on-chain | nothing — refunds the unused deposit |
+
+```typescript
+const channel = await qn.rpc.mppOpen("1000000");   // persist this object
+const newTotal = (BigInt(channel.cumulativeSpent) + BigInt(channel.perCall)).toString();
+const result = await qn.rpc.mppSessionCall(
+  "eth_blockNumber", "base-sepolia", channel, newTotal,
+);
+// On success, store newTotal as the channel's cumulativeSpent.
+```
+
+**Things to know:**
+
+- **Persist the channel state.** The gateway exposes no read-only channel endpoint, so a
+  lost local record means opening (and funding) a new channel.
+- **`mppStatus` is not free.** The gateway prices every session POST as a chargeable
+  request and computes the balance from the *new* spend a voucher authorizes, so the
+  probe advances `cumulativeSpent` by `perCall` exactly like a call. Re-persist the
+  advanced total. It raises `PaymentUnsupportedError` before any network I/O when the
+  channel has no room left for the probe.
+- **The lifecycle takes no query network.** A channel is scoped by the configured pay
+  network and asset, so one channel funds calls to every supported network. Only
+  `mppSessionCall` takes a network, because it routes an RPC method.
+- **Amounts are decimal strings, not numbers.** They are `u128` in the core; a JS `number` is an f64 that loses precision above 2^53, so pass and store them as strings.
+- **Advance `cumulativeSpent` only after a success.** A voucher authorizes the running total
+  *after* the call; re-presenting the current high-water mark authorizes zero and is
+  always refused with `insufficient-balance`.
+
+
+
 ## Error Handling
 
 Every binding exposes a typed exception hierarchy derived from the core `SdkError`
@@ -1689,8 +1919,13 @@ subclass to branch on transport vs. API semantics.
 | `ConnectionError`    | connection refused / DNS / TLS (subclass of `HttpError`)    | —                    |
 | `ApiError`           | non-2xx HTTP response                                       | `status`, `body`     |
 | `DecodeError`        | 2xx response but JSON parse failed                          | `body`               |
+| `RpcError`           | JSON-RPC call returned an `error` member                    | `code`, `message`    |
+| `PaymentError`       | base class for the crypto-micropayment lane                 | —                    |
+| `PaymentUnsupportedError` | no offered payment option matched your selector (or all were over `max_amount`/unsupported) | — |
+| `PaymentRejectedError` | the gateway rejected a signed payment (terminal, one resend only) | `status`, `body` |
+| `PaymentIndeterminateError` | paid request sent but response lost — MAY have been charged; do NOT blindly retry | — |
 
-Class names: Importable from `@quicknode/sdk`: `QuicknodeError`, `ConfigError`, `HttpError`, `TimeoutError`, `ConnectionError`, `ApiError`, `DecodeError`. All extend `Error`.
+Class names: Importable from `@quicknode/sdk`: `QuicknodeError`, `ConfigError`, `HttpError`, `TimeoutError`, `ConnectionError`, `ApiError`, `DecodeError`, `RpcError`, `PaymentError`, `PaymentUnsupportedError`, `PaymentRejectedError`, `PaymentIndeterminateError`. All extend `Error`.
 
 ```typescript
 // Node.js

package/errors.js

@@ -54,7 +54,48 @@ class DecodeError extends QuicknodeError {
   }
 }
 
-const TAG_RE = /^\[(Config|Http|Timeout|Connect|Api|Decode)\|([^|]+)\|([^\]]+)\](.*)$/s;
+class RpcError extends QuicknodeError {
+  constructor(message, code) {
+    super(message);
+    this.name = "RpcError";
+    this.code = code;
+  }
+}
+
+// Payment-lane errors. PaymentError is the family base; PaymentRejectedError
+// carries the gateway status/body; PaymentIndeterminateError is its own class
+// so callers can catch "may have been charged — do not retry" distinctly.
+class PaymentError extends QuicknodeError {
+  constructor(message) {
+    super(message);
+    this.name = "PaymentError";
+  }
+}
+
+class PaymentUnsupportedError extends PaymentError {
+  constructor(message) {
+    super(message);
+    this.name = "PaymentUnsupportedError";
+  }
+}
+
+class PaymentRejectedError extends PaymentError {
+  constructor(message, status, body) {
+    super(message);
+    this.name = "PaymentRejectedError";
+    this.status = status;
+    this.body = body;
+  }
+}
+
+class PaymentIndeterminateError extends PaymentError {
+  constructor(message) {
+    super(message);
+    this.name = "PaymentIndeterminateError";
+  }
+}
+
+const TAG_RE = /^\[(Config|Http|Timeout|Connect|Api|Decode|Rpc|PaymentUnsupported|PaymentRejected|PaymentIndeterminate)\|([^|]+)\|([^\]]+)\](.*)$/s;
 
 function fromNapiError(err) {
   if (!(err instanceof Error)) return err;
@@ -82,6 +123,11 @@ function fromNapiError(err) {
     case "Http": return new HttpError(msg);
     case "Api": return new ApiError(msg, Number(statusStr), body);
     case "Decode": return new DecodeError(msg, body);
+    // For Rpc, statusStr is the JSON-RPC code and body is its message.
+    case "Rpc": return new RpcError(body || msg, Number(statusStr));
+    case "PaymentUnsupported": return new PaymentUnsupportedError(msg);
+    case "PaymentRejected": return new PaymentRejectedError(msg, Number(statusStr), body);
+    case "PaymentIndeterminate": return new PaymentIndeterminateError(msg);
     default: return err;
   }
 }
@@ -116,6 +162,11 @@ module.exports = {
   ConnectionError,
   ApiError,
   DecodeError,
+  RpcError,
+  PaymentError,
+  PaymentUnsupportedError,
+  PaymentRejectedError,
+  PaymentIndeterminateError,
   fromNapiError,
   wrapClient,
 };

package/index.d.ts

@@ -221,6 +221,23 @@ export interface BulkUpdateEndpointStatusResponse {
   error?: string
 }
 
+/**
+ * A minted session JWT plus the endpoint it authenticates against and its
+ * wall-clock expiry. This is the unit cached by the RPC client and the unit a
+ * host persists between processes (e.g. the CLI's on-disk token cache).
+ *
+ * `exp_unix` is the JWT `exp` claim (unix seconds), used directly so it
+ * survives a process restart (unlike a monotonic `Instant`).
+ */
+export interface CachedToken {
+  /** The provisioned tooling-access endpoint URL the JWT authenticates against. */
+  endpointUrl: string
+  /** The minted ES256 session JWT, presented as a Bearer token. */
+  token: string
+  /** JWT `exp` claim in unix seconds. */
+  expUnix: number
+}
+
 /** A blockchain supported by Quicknode along with its networks. */
 export interface Chain {
   /** Chain slug (e.g. `ethereum`). */
@@ -1350,6 +1367,55 @@ export interface Payment {
   marketplaceAmount?: string
 }
 
+/**
+ * Binding-facing crypto-micropayment configuration. **Plain data** — all
+ * fields are strings so this can be a `napi(object)` / `pyclass` / Ruby hash;
+ * it is converted to the internal `enum Signer` + resolved config at the Rust
+ * boundary. The private `key` field stays readable to the caller, but the
+ * SDK's own `Debug` redacts it (below) so an SDK log line or panic can't leak
+ * it.
+ *
+ * **Do not log your own `PaymentConfig`** — `println!("{config:?}")` on the
+ * derived-Debug *binding* object (napi/pyclass/hash) still shows the raw key.
+ * Only the SDK's internal rendering is redacted.
+ */
+export interface PaymentConfig {
+  /** Payment protocol: `"x402"` (pay-per-request) or `"mpp"` (MPP charge). */
+  scheme: string
+  /**
+   * Raw private key. EVM/Tempo: hex (with or without `0x`). Solana: base58
+   * 64-byte secret key.
+   */
+  key: string
+  /**
+   * CAIP-2 pay network selector, e.g. `"eip155:84532"` (x402/EVM),
+   * `"solana:5eykt4…"` (x402/Solana), or `"eip155:42431"` (MPP/Tempo).
+   */
+  payNetwork: string
+  /**
+   * Asset (token) address/mint to pay in. Matches the offered menu entry's
+   * `asset`. EVM: token contract hex. Solana: mint base58.
+   */
+  asset: string
+  /**
+   * Spend ceiling in base units of `asset` (integer string). **Required.**
+   * The selector skips any offered entry above this, and the driver refuses
+   * to sign one — guarding against a buggy/hostile gateway overcharging a
+   * custodied key.
+   */
+  maxAmount: string
+  /**
+   * Explicit Solana RPC URL for x402/Solana payment-build reads: the mint
+   * (for its decimals and owning token program) and a recent blockhash, so
+   * two reads per payment. Optional; when unset the SDK falls back to a
+   * public Solana RPC matching the pay cluster. **Set this at any real
+   * volume** — the public default rate-limits aggressively.
+   */
+  svmRpcUrl?: string
+  /** Test-only gateway base override (points the lane at a mock gateway). */
+  baseUrlOverride?: string
+}
+
 /** Configuration for delivering stream batches to a PostgreSQL database. */
 export interface PostgresAttributes {
   /** Database host. */
@@ -1465,6 +1531,51 @@ export interface ResendTeamInviteResponse {
   error?: string
 }
 
+export interface RpcConfig {
+  /**
+   * Custom HTTP URL to send JSON-RPC calls to, bypassing the Tooling Access
+   * endpoint. When set, every `rpc.call` on this client goes straight to this
+   * URL with NO session token minted or attached — the URL is treated as a
+   * self-authenticating endpoint (e.g. a provisioned `.quiknode.pro` URL that
+   * already embeds its token, or a self-hosted node). A per-call
+   * `endpoint_url` overrides this default. Unset means tooling-JWT mode.
+   */
+  endpointUrl?: string
+  /**
+   * Optional pre-existing token to seed the in-memory cache (e.g. loaded
+   * from a host's on-disk cache). Advisory: a malformed or expired seed is
+   * treated as a cache miss and a fresh token is minted.
+   */
+  seed?: CachedToken
+  /**
+   * Seconds before `exp` at which the client proactively refreshes. The
+   * margin also absorbs clock skew between client and endpoint. Defaults to
+   * 60 when unset.
+   */
+  refreshMarginSecs?: number
+  /**
+   * Per-network URL map for multichain routing: network key (e.g.
+   * `"solana-mainnet"`, `"polygon"`) -> full http_url. Built from
+   * `admin.get_endpoint_urls(...).multichain_urls`. When set, `rpc.call` with
+   * a `network` resolves the target URL here. Optional; the default-network
+   * call path needs no map.
+   */
+  networks?: Record<string, string>
+  /**
+   * Crypto-micropayment lane. When set, `rpc.call` pays per request with a
+   * stablecoin against Quicknode's x402/MPP gateways instead of using the
+   * account API key + session JWT. `#[serde(skip)]` so `from_env` can never
+   * populate it — an env-derived private key is exactly what we don't want;
+   * callers must pass this programmatically. The field is always present
+   * (plain data), but the payment lane is only wired into `rpc.call` when a
+   * crypto feature (`payments`/`payments-svm`/`payments-tempo`) is enabled;
+   * built without any of them, a set `payment` is ignored and `rpc.call`
+   * keeps its normal tooling-JWT behavior. The precompiled Python/Node/Ruby
+   * packages always ship with the payment features on.
+   */
+  payment?: PaymentConfig
+}
+
 /** Configuration for delivering stream batches to an S3-compatible object store. */
 export interface S3Attributes {
   /** S3 service endpoint (e.g. `s3.amazonaws.com`). */
@@ -1490,13 +1601,24 @@ export interface S3Attributes {
 }
 
 export interface SdkFullConfig {
-  apiKey: string
+  /**
+   * Account API key. **Optional** so a keyless SDK can be built for the
+   * crypto-micropayment lane (`rpc.call` with `RpcConfig.payment`). When
+   * absent, no `x-api-key` header is installed: the payment lane works, while
+   * the keyed surfaces (admin/streams/webhooks/kvstore/sql and tooling-JWT
+   * `rpc.call`) send un-authenticated requests and the gateway rejects them
+   * (surfacing as an `ApiError`, typically 401). `from_env` still requires
+   * the key (validated in `from_config`) — only programmatic construction
+   * may omit it.
+   */
+  apiKey?: string
   http?: HttpConfig
   admin?: AdminConfig
   streams?: StreamsConfig
   webhooks?: WebhooksConfig
   kvstore?: KvStoreConfig
   sql?: SqlConfig
+  rpc?: RpcConfig
 }
 
 /** A single security feature's name, status, and optional value. */
@@ -1778,6 +1900,23 @@ export interface TestFilterResponse {
   logs: Array<string>
 }
 
+/**
+ * Current Tooling Access status for the account. `enabled` is the source of
+ * truth — a previously-provisioned-but-disabled account may still report a
+ * non-null `endpoint_url`.
+ */
+export interface ToolingAccessStatus {
+  enabled: boolean
+  endpointUrl?: string
+  enabledAt?: string
+  /**
+   * The provisioned endpoint's id. Used to fetch the per-network URL map
+   * (`get_endpoint_urls`) for multichain routing. `None` on control planes
+   * that don't yet return it.
+   */
+  endpointId?: string
+}
+
 /** Parameters for `update_endpoint`. */
 export interface UpdateEndpointRequest {
   /** New human-readable label. */
@@ -2265,6 +2404,24 @@ export declare class AdminApiClient {
    * chain slug rejects with `ApiError` (status 404).
    */
   getApiCredits(chain: string): Promise<GetApiCreditsResponse>
+  /**
+   * Returns the current Tooling Access status for the account. Inspect
+   * `enabled` to decide whether to enable provisioning.
+   */
+  toolingAccessStatus(): Promise<ToolingAccessStatus>
+  /**
+   * Enables (provisions) Tooling Access. Idempotent. Requires an admin role
+   * and an eligible plan.
+   */
+  enableToolingAccess(): Promise<ToolingAccessStatus>
+  /** Disables Tooling Access, pausing the endpoint. Idempotent. */
+  disableToolingAccess(): Promise<ToolingAccessStatus>
+  /**
+   * Mints a short-lived session JWT for the provisioned Tooling Access
+   * endpoint. Returns the endpoint URL, the JWT, and its expiry. Requires
+   * Tooling Access to be enabled first.
+   */
+  mintToolingToken(): Promise<CachedToken>
   /**
    * Returns the account's invoices, including id, status, billing reason,
    * amounts due and paid, line items with descriptions and billing periods,
@@ -2424,10 +2581,128 @@ export declare class QuicknodeSdk {
   get kvstore(): KvStoreApiClient
   /** Returns the sql sub-client. */
   get sql(): SqlApiClient
+  /** Returns the JSON-RPC sub-client. */
+  get rpc(): RpcApiClient
   /** Creates a new SDK instance using configuration from environment variables. */
   static fromEnv(): QuicknodeSdk
 }
 
+export declare class RpcApiClient {
+  /**
+   * Makes a JSON-RPC call against the account's Tooling Access endpoint,
+   * authenticated with a short-lived session JWT (minted and refreshed
+   * automatically). `params` accepts an array (positional) or object
+   * (by-name) and defaults to `[]`. `network` selects a chain on the
+   * multichain endpoint (a key in the seeded network map, e.g.
+   * `"solana-mainnet"`); omit for the endpoint's default network.
+   *
+   * `endpointUrl` sends this call to a custom HTTP URL instead, bypassing the
+   * Tooling Access endpoint and the session JWT (no Authorization header is
+   * attached). It overrides the client-wide `RpcConfig.endpointUrl` default.
+   * Passing both `endpointUrl` and `network` throws (they are mutually
+   * exclusive). Returns the JSON-RPC `result`; a JSON-RPC error is thrown as
+   * `RpcError`.
+   */
+  call(method: string, params?: any | undefined | null, network?: string | undefined | null, endpointUrl?: string | undefined | null): Promise<any>
+  /**
+   * Like `call`, but also returns the crypto-micropayment settlement
+   * receipt. Resolves to `{ result, paymentReceipt }` where `paymentReceipt`
+   * is `{ method, status, timestamp, reference }` on the MPP payment lane and
+   * `null` for x402 and every non-payment lane (identical to `call`).
+   */
+  callWithReceipt(method: string, params?: any | undefined | null, network?: string | undefined | null, endpointUrl?: string | undefined | null): Promise<any>
+  /**
+   * Seeds the per-network URL map for multichain routing (network key ->
+   * full http_url), typically built from
+   * `admin.getEndpointUrls(...).multichainUrls`.
+   */
+  setNetworks(networks: Record<string, string>): void
+  /**
+   * Discards the in-memory cached token, forcing the next call to mint a
+   * fresh one. Use when the cached token is known stale beyond expiry.
+   */
+  clearCachedToken(): void
+  /**
+   * Returns a snapshot of the currently cached session token, or `null` if
+   * no token has been minted or seeded yet. Hosts use this to persist the
+   * token between processes.
+   */
+  currentToken(): CachedToken | null
+  /**
+   * The configured payment wallet's on-chain address (EVM/Tempo `0x…` hex,
+   * Solana base58), derived offline from the key with no network round trip.
+   */
+  paymentAddress(): string
+  /**
+   * Authenticates against the x402 gateway with a SIWX message and resolves
+   * to `{ token, expUnix, accountId }`. Free — no funds move. Persist the
+   * object and pass it back to the `gateway*` methods.
+   */
+  gatewayAuthenticate(): Promise<any>
+  /**
+   * Reads the account's current x402 credit balance. Resolves to
+   * `{ accountId, credits }`. `session` comes from `gatewayAuthenticate`.
+   */
+  gatewayCredits(session: any): Promise<any>
+  /**
+   * Buys a block of credits, settling the gateway's offer with the same
+   * signer construction as the per-request lane. Resolves to the
+   * post-purchase `{ accountId, credits }`. Single-attempt: a paid lane never
+   * blind-retries.
+   */
+  gatewayBuyCredits(session: any, network: string): Promise<any>
+  /**
+   * Requests testnet tokens from the x402 faucet. Resolves to the funding
+   * transaction `{ accountId, transactionHash }` — NOT a balance; call
+   * `gatewayCredits` afterwards for that. Allowed once per account.
+   */
+  gatewayDrip(session: any): Promise<any>
+  /**
+   * Makes one x402 drawdown JSON-RPC call with the session as a Bearer
+   * token, drawing 1 credit on success. Resolves to the unwrapped JSON-RPC
+   * `result`. Single-attempt; re-authenticate on a 401/403 `ApiError`.
+   */
+  gatewayDrawdownCall(method: string, session: any, network: string, params?: any | undefined | null): Promise<any>
+  /**
+   * Opens an MPP payment channel by depositing `deposit` base units (a
+   * decimal string) into the escrow. Resolves to the channel state — persist
+   * it; the gateway has no read-only channel endpoint, so a lost record means
+   * opening a new channel. Moves real funds; single-attempt.
+   *
+   * Takes no network: the channel is scoped by the configured pay network and
+   * asset, so one channel funds calls to every supported network.
+   */
+  mppOpen(deposit: string): Promise<any>
+  /**
+   * Adds `additionalDeposit` base units (a decimal string) to an open
+   * channel. Resolves to the updated channel state. Moves real funds;
+   * single-attempt.
+   */
+  mppTopUp(channel: any, additionalDeposit: string): Promise<any>
+  /**
+   * Cooperatively closes a channel: settles the final cumulative spend
+   * on-chain and refunds the unused deposit. Single-attempt.
+   */
+  mppClose(channel: any): Promise<void>
+  /**
+   * Fetches the gateway's view of the channel as
+   * `{ channelId, acceptedCumulative, spent }` (amounts are decimal strings).
+   *
+   * **This costs one request unit** and advances the voucher by `perCall`,
+   * exactly like a session call — persist the advanced `cumulativeSpent`.
+   * Rejects with `PaymentUnsupportedError` before any network I/O when the
+   * channel has no room left for the probe.
+   */
+  mppStatus(channel: any): Promise<any>
+  /**
+   * Makes one MPP session-lane JSON-RPC call, authorizing it with a
+   * cumulative voucher for `newCumulative` (a decimal string: the running
+   * total AFTER this call). Resolves to the unwrapped JSON-RPC `result`.
+   * Single-attempt; advance the persisted `cumulativeSpent` on success.
+   */
+  mppSessionCall(method: string, network: string, channel: any, newCumulative: string, params?: any | undefined | null): Promise<any>
+}
+
 export declare class SqlApiClient {
   /** Executes a SQL query against the given cluster and returns the result set. */
   query(query: string, clusterId: string): Promise<QueryResponseNode>
@@ -2621,6 +2896,17 @@ export interface CreateWebhookFromTemplateParamsNode {
   templateArgs: any
 }
 
+/**
+ * Generates a fresh payment keypair for `chain` (`"evm"`, `"svm"`, or
+ * `"tempo"`). Returns `{ address, chain, key }` where `key` is the raw private
+ * key in the format the `keyFile` config reads.
+ *
+ * The key is returned exactly once, at generation: nothing in the SDK stores or
+ * re-derives it, so persist it before discarding the object. Randomness comes
+ * from the OS CSPRNG.
+ */
+export declare function generatePaymentWallet(chain: string): any
+
 export interface ListStreamsResponseNode {
   data: Array<StreamNode>
   pageInfo: PageInfo

package/index.js

@@ -77,8 +77,8 @@ function requireNative() {
       try {
         const binding = require('@quicknode/sdk-android-arm64')
         const bindingPackageVersion = require('@quicknode/sdk-android-arm64/package.json').version
-        if (bindingPackageVersion !== '3.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 3.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 3.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -93,8 +93,8 @@ function requireNative() {
       try {
         const binding = require('@quicknode/sdk-android-arm-eabi')
         const bindingPackageVersion = require('@quicknode/sdk-android-arm-eabi/package.json').version
-        if (bindingPackageVersion !== '3.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 3.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 3.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -114,8 +114,8 @@ function requireNative() {
       try {
         const binding = require('@quicknode/sdk-win32-x64-gnu')
         const bindingPackageVersion = require('@quicknode/sdk-win32-x64-gnu/package.json').version
-        if (bindingPackageVersion !== '3.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 3.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 3.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -130,8 +130,8 @@ function requireNative() {
       try {
         const binding = require('@quicknode/sdk-win32-x64-msvc')
         const bindingPackageVersion = require('@quicknode/sdk-win32-x64-msvc/package.json').version
-        if (bindingPackageVersion !== '3.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 3.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 3.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -147,8 +147,8 @@ function requireNative() {
       try {
         const binding = require('@quicknode/sdk-win32-ia32-msvc')
         const bindingPackageVersion = require('@quicknode/sdk-win32-ia32-msvc/package.json').version
-        if (bindingPackageVersion !== '3.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 3.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 3.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -163,8 +163,8 @@ function requireNative() {
       try {
         const binding = require('@quicknode/sdk-win32-arm64-msvc')
         const bindingPackageVersion = require('@quicknode/sdk-win32-arm64-msvc/package.json').version
-        if (bindingPackageVersion !== '3.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 3.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 3.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -182,8 +182,8 @@ function requireNative() {
     try {
       const binding = require('@quicknode/sdk-darwin-universal')
       const bindingPackageVersion = require('@quicknode/sdk-darwin-universal/package.json').version
-      if (bindingPackageVersion !== '3.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-        throw new Error(`Native binding package version mismatch, expected 3.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+      if (bindingPackageVersion !== '3.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+        throw new Error(`Native binding package version mismatch, expected 3.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
       }
       return binding
     } catch (e) {
@@ -198,8 +198,8 @@ function requireNative() {
       try {
         const binding = require('@quicknode/sdk-darwin-x64')
         const bindingPackageVersion = require('@quicknode/sdk-darwin-x64/package.json').version
-        if (bindingPackageVersion !== '3.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 3.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 3.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -214,8 +214,8 @@ function requireNative() {
       try {
         const binding = require('@quicknode/sdk-darwin-arm64')
         const bindingPackageVersion = require('@quicknode/sdk-darwin-arm64/package.json').version
-        if (bindingPackageVersion !== '3.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 3.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 3.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -234,8 +234,8 @@ function requireNative() {
       try {
         const binding = require('@quicknode/sdk-freebsd-x64')
         const bindingPackageVersion = require('@quicknode/sdk-freebsd-x64/package.json').version
-        if (bindingPackageVersion !== '3.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 3.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 3.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -250,8 +250,8 @@ function requireNative() {
       try {
         const binding = require('@quicknode/sdk-freebsd-arm64')
         const bindingPackageVersion = require('@quicknode/sdk-freebsd-arm64/package.json').version
-        if (bindingPackageVersion !== '3.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 3.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 3.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -271,8 +271,8 @@ function requireNative() {
         try {
           const binding = require('@quicknode/sdk-linux-x64-musl')
           const bindingPackageVersion = require('@quicknode/sdk-linux-x64-musl/package.json').version
-          if (bindingPackageVersion !== '3.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 3.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '3.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 3.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
           }
           return binding
         } catch (e) {
@@ -287,8 +287,8 @@ function requireNative() {
         try {
           const binding = require('@quicknode/sdk-linux-x64-gnu')
           const bindingPackageVersion = require('@quicknode/sdk-linux-x64-gnu/package.json').version
-          if (bindingPackageVersion !== '3.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 3.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '3.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 3.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
           }
           return binding
         } catch (e) {
@@ -305,8 +305,8 @@ function requireNative() {
         try {
           const binding = require('@quicknode/sdk-linux-arm64-musl')
           const bindingPackageVersion = require('@quicknode/sdk-linux-arm64-musl/package.json').version
-          if (bindingPackageVersion !== '3.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 3.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '3.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 3.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
           }
           return binding
         } catch (e) {
@@ -321,8 +321,8 @@ function requireNative() {
         try {
           const binding = require('@quicknode/sdk-linux-arm64-gnu')
           const bindingPackageVersion = require('@quicknode/sdk-linux-arm64-gnu/package.json').version
-          if (bindingPackageVersion !== '3.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 3.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '3.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 3.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
           }
           return binding
         } catch (e) {
@@ -339,8 +339,8 @@ function requireNative() {
         try {
           const binding = require('@quicknode/sdk-linux-arm-musleabihf')
           const bindingPackageVersion = require('@quicknode/sdk-linux-arm-musleabihf/package.json').version
-          if (bindingPackageVersion !== '3.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 3.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '3.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 3.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
           }
           return binding
         } catch (e) {
@@ -355,8 +355,8 @@ function requireNative() {
         try {
           const binding = require('@quicknode/sdk-linux-arm-gnueabihf')
           const bindingPackageVersion = require('@quicknode/sdk-linux-arm-gnueabihf/package.json').version
-          if (bindingPackageVersion !== '3.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 3.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '3.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 3.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
           }
           return binding
         } catch (e) {
@@ -373,8 +373,8 @@ function requireNative() {
         try {
           const binding = require('@quicknode/sdk-linux-loong64-musl')
           const bindingPackageVersion = require('@quicknode/sdk-linux-loong64-musl/package.json').version
-          if (bindingPackageVersion !== '3.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 3.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '3.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 3.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
           }
           return binding
         } catch (e) {
@@ -389,8 +389,8 @@ function requireNative() {
         try {
           const binding = require('@quicknode/sdk-linux-loong64-gnu')
           const bindingPackageVersion = require('@quicknode/sdk-linux-loong64-gnu/package.json').version
-          if (bindingPackageVersion !== '3.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 3.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '3.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 3.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
           }
           return binding
         } catch (e) {
@@ -407,8 +407,8 @@ function requireNative() {
         try {
           const binding = require('@quicknode/sdk-linux-riscv64-musl')
           const bindingPackageVersion = require('@quicknode/sdk-linux-riscv64-musl/package.json').version
-          if (bindingPackageVersion !== '3.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 3.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '3.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 3.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
           }
           return binding
         } catch (e) {
@@ -423,8 +423,8 @@ function requireNative() {
         try {
           const binding = require('@quicknode/sdk-linux-riscv64-gnu')
           const bindingPackageVersion = require('@quicknode/sdk-linux-riscv64-gnu/package.json').version
-          if (bindingPackageVersion !== '3.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 3.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '3.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 3.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
           }
           return binding
         } catch (e) {
@@ -440,8 +440,8 @@ function requireNative() {
       try {
         const binding = require('@quicknode/sdk-linux-ppc64-gnu')
         const bindingPackageVersion = require('@quicknode/sdk-linux-ppc64-gnu/package.json').version
-        if (bindingPackageVersion !== '3.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 3.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 3.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -456,8 +456,8 @@ function requireNative() {
       try {
         const binding = require('@quicknode/sdk-linux-s390x-gnu')
         const bindingPackageVersion = require('@quicknode/sdk-linux-s390x-gnu/package.json').version
-        if (bindingPackageVersion !== '3.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 3.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 3.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -476,8 +476,8 @@ function requireNative() {
       try {
         const binding = require('@quicknode/sdk-openharmony-arm64')
         const bindingPackageVersion = require('@quicknode/sdk-openharmony-arm64/package.json').version
-        if (bindingPackageVersion !== '3.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 3.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 3.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -492,8 +492,8 @@ function requireNative() {
       try {
         const binding = require('@quicknode/sdk-openharmony-x64')
         const bindingPackageVersion = require('@quicknode/sdk-openharmony-x64/package.json').version
-        if (bindingPackageVersion !== '3.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 3.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 3.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -508,8 +508,8 @@ function requireNative() {
       try {
         const binding = require('@quicknode/sdk-openharmony-arm')
         const bindingPackageVersion = require('@quicknode/sdk-openharmony-arm/package.json').version
-        if (bindingPackageVersion !== '3.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 3.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 3.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -588,6 +588,8 @@ module.exports.WebhookTemplateId = nativeBinding.WebhookTemplateId
 module.exports.AdminApiClient = nativeBinding.AdminApiClient
 module.exports.KvStoreApiClient = nativeBinding.KvStoreApiClient
 module.exports.QuicknodeSdk = nativeBinding.QuicknodeSdk
+module.exports.RpcApiClient = nativeBinding.RpcApiClient
 module.exports.SqlApiClient = nativeBinding.SqlApiClient
 module.exports.StreamsApiClient = nativeBinding.StreamsApiClient
 module.exports.WebhooksApiClient = nativeBinding.WebhooksApiClient
+module.exports.generatePaymentWallet = nativeBinding.generatePaymentWallet

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quicknode/sdk",
-  "version": "3.6.0",
+  "version": "3.8.0",
   "description": "Quicknode SDK",
   "repository": {
     "type": "git",
@@ -54,10 +54,10 @@
   },
   "license": "MIT",
   "optionalDependencies": {
-    "@quicknode/sdk-linux-x64-gnu": "3.6.0",
-    "@quicknode/sdk-linux-arm64-gnu": "3.6.0",
-    "@quicknode/sdk-linux-x64-musl": "3.6.0",
-    "@quicknode/sdk-linux-arm64-musl": "3.6.0",
-    "@quicknode/sdk-darwin-arm64": "3.6.0"
+    "@quicknode/sdk-linux-x64-gnu": "3.8.0",
+    "@quicknode/sdk-linux-arm64-gnu": "3.8.0",
+    "@quicknode/sdk-linux-x64-musl": "3.8.0",
+    "@quicknode/sdk-linux-arm64-musl": "3.8.0",
+    "@quicknode/sdk-darwin-arm64": "3.8.0"
   }
 }

package/sdk.d.ts

@@ -16,6 +16,7 @@ import {
   XrplWalletFilterTemplate,
   HyperliquidWalletEventsFilterTemplate,
   StellarWalletTransactionsFilterTemplate,
+  RpcApiClient,
 } from "./index";
 
 // Stream destination attributes (input). The inner key is `attributes` rather
@@ -326,8 +327,102 @@ export type {
   ChainSchemaNode,
   TableSchemaNode,
   ColumnSchemaNode,
+  // rpc / tooling access
+  RpcConfig,
+  CachedToken,
+  ToolingAccessStatus,
+  RpcApiClient,
+  // payment lane
+  PaymentConfig,
 } from "./index";
 
+// A settlement receipt for the crypto-micropayment lane. Returned inside
+// `RpcCallResponse.paymentReceipt` by `rpc.callWithReceipt`. `reference` is the
+// settlement transaction hash. Present only on the MPP lane; `null` otherwise.
+export interface PaymentReceipt {
+  method: string;
+  status: string;
+  timestamp: string;
+  reference: string;
+}
+
+// The result of `rpc.callWithReceipt`: the JSON-RPC `result` plus the optional
+// settlement receipt (`null` for x402 and non-payment lanes).
+export interface RpcCallResponse {
+  result: any;
+  paymentReceipt: PaymentReceipt | null;
+}
+
+// ── Payment lanes ──────────────────────────────────────────────
+//
+// Base-unit amounts are `string`, not `number`: they are u128 in the core and a
+// JS number is an f64 that loses precision above 2^53. Pass and store them as
+// decimal strings.
+
+// An x402 gateway session (from `rpc.gatewayAuthenticate`). `token` is a live
+// bearer credential — persist it, but keep it out of logs.
+export interface GatewaySession {
+  token: string;
+  expUnix: number;
+  accountId: string;
+}
+
+// An x402 credit balance (`rpc.gatewayCredits` / `rpc.gatewayBuyCredits`).
+export interface CreditBalance {
+  accountId: string;
+  credits: number;
+}
+
+// The faucet result (`rpc.gatewayDrip`): the on-chain funding transaction, NOT
+// a balance. Call `rpc.gatewayCredits` afterwards to read the new balance.
+export interface DripReceipt {
+  accountId: string;
+  transactionHash: string;
+}
+
+// Local state for an open MPP payment channel (`rpc.mppOpen` /
+// `rpc.mppTopUp`). Persist this verbatim: the gateway has no read-only channel
+// endpoint, so a lost record means opening a new channel.
+export interface ChannelState {
+  channelId: string;
+  token: string;
+  payee: string;
+  salt: string;
+  authorizedSigner: string;
+  escrowContract: string;
+  /** Base units, decimal string. */
+  deposit: string;
+  /** Base units, decimal string. */
+  cumulativeSpent: string;
+  /** The gateway's per-call price, in base units, as a decimal string. */
+  perCall: string;
+  chainId: number;
+}
+
+// The gateway's view of a channel (`rpc.mppStatus`).
+export interface ChannelStatus {
+  channelId: string;
+  /** Base units, decimal string. */
+  acceptedCumulative: string;
+  /** Base units, decimal string. */
+  spent: string;
+}
+
+// A freshly generated payment wallet (`generatePaymentWallet`). `key` is the raw
+// private key, returned exactly once at generation — nothing in the SDK stores
+// or re-derives it, so persist it before discarding the object.
+export interface GeneratedWallet {
+  address: string;
+  chain: "evm" | "svm" | "tempo";
+  key: string;
+}
+
+/**
+ * Generates a fresh payment keypair. Offline: no network call, no funds.
+ * Randomness comes from the OS CSPRNG.
+ */
+export function generatePaymentWallet(chain: "evm" | "svm" | "tempo"): GeneratedWallet;
+
 // const enums must use `export` (not `export type`) so they are usable as values
 export {
   StreamRegion,
@@ -392,6 +487,61 @@ export interface SqlApiClientTyped {
   getSchema(clusterId: string): Promise<ChainSchemaNode>;
 }
 
+// Retypes the payment-lane returns from napi's `any` to the interfaces above.
+// napi emits `any` for every method returning a `serde_json::Value`, so without
+// this the declared payment interfaces would be documentation only and a
+// mistyped field would not be an error. Keep method signatures in sync with the
+// napi-generated RpcApiClient in ./index.d.ts.
+export interface RpcApiClientTyped
+  extends Omit<
+    RpcApiClient,
+    | "callWithReceipt"
+    | "gatewayAuthenticate"
+    | "gatewayCredits"
+    | "gatewayBuyCredits"
+    | "gatewayDrip"
+    | "gatewayDrawdownCall"
+    | "mppOpen"
+    | "mppTopUp"
+    | "mppClose"
+    | "mppStatus"
+    | "mppSessionCall"
+  > {
+  callWithReceipt(
+    method: string,
+    params?: any | undefined | null,
+    network?: string | undefined | null,
+    endpointUrl?: string | undefined | null
+  ): Promise<RpcCallResponse>;
+  gatewayAuthenticate(): Promise<GatewaySession>;
+  gatewayCredits(session: GatewaySession): Promise<CreditBalance>;
+  gatewayBuyCredits(
+    session: GatewaySession,
+    network: string
+  ): Promise<CreditBalance>;
+  gatewayDrip(session: GatewaySession): Promise<DripReceipt>;
+  gatewayDrawdownCall(
+    method: string,
+    session: GatewaySession,
+    network: string,
+    params?: any | undefined | null
+  ): Promise<any>;
+  mppOpen(deposit: string): Promise<ChannelState>;
+  mppTopUp(
+    channel: ChannelState,
+    additionalDeposit: string
+  ): Promise<ChannelState>;
+  mppClose(channel: ChannelState): Promise<void>;
+  mppStatus(channel: ChannelState): Promise<ChannelStatus>;
+  mppSessionCall(
+    method: string,
+    network: string,
+    channel: ChannelState,
+    newCumulative: string,
+    params?: any | undefined | null
+  ): Promise<any>;
+}
+
 export class QuicknodeSdk {
   constructor(config: SdkFullConfig);
   static fromEnv(): QuicknodeSdk;
@@ -400,6 +550,7 @@ export class QuicknodeSdk {
   webhooks: WebhooksApiClientTyped;
   kvstore: _QuicknodeSdk["kvstore"];
   sql: SqlApiClientTyped;
+  rpc: RpcApiClientTyped;
 }
 
 // Typed static factory methods producing each discriminated variant of
@@ -450,3 +601,16 @@ export class ApiError extends QuicknodeError {
 export class DecodeError extends QuicknodeError {
   body: string;
 }
+export class RpcError extends QuicknodeError {
+  code: number;
+}
+// Payment-lane errors (crypto-micropayment `rpc.call`). Catch PaymentError to
+// handle them all. PaymentIndeterminateError means the paid request was sent
+// but its response was lost — the payment MAY have settled, so do NOT retry.
+export class PaymentError extends QuicknodeError {}
+export class PaymentUnsupportedError extends PaymentError {}
+export class PaymentRejectedError extends PaymentError {
+  status: number;
+  body: string;
+}
+export class PaymentIndeterminateError extends PaymentError {}

package/sdk.js

@@ -16,6 +16,7 @@ class QuicknodeSdk {
     this.webhooks = errors.wrapClient(this._inner.webhooks);
     this.kvstore = errors.wrapClient(this._inner.kvstore);
     this.sql = errors.wrapClient(this._inner.sql);
+    this.rpc = errors.wrapClient(this._inner.rpc);
   }
 
   static fromEnv() {
@@ -30,6 +31,7 @@ class QuicknodeSdk {
     instance.webhooks = errors.wrapClient(instance._inner.webhooks);
     instance.kvstore = errors.wrapClient(instance._inner.kvstore);
     instance.sql = errors.wrapClient(instance._inner.sql);
+    instance.rpc = errors.wrapClient(instance._inner.rpc);
     return instance;
   }
 }
@@ -76,10 +78,20 @@ class TemplateArgs {
   }
 }
 
+// Translate module-level napi errors; wrapClient only handles clients.
+function generatePaymentWallet(chain) {
+  try {
+    return _index.generatePaymentWallet(chain);
+  } catch (e) {
+    throw errors.fromNapiError(e);
+  }
+}
+
 module.exports = {
   ..._index,
   QuicknodeSdk,
   TemplateArgs,
+  generatePaymentWallet,
   QuicknodeError: errors.QuicknodeError,
   ConfigError: errors.ConfigError,
   HttpError: errors.HttpError,
@@ -87,4 +99,9 @@ module.exports = {
   ConnectionError: errors.ConnectionError,
   ApiError: errors.ApiError,
   DecodeError: errors.DecodeError,
+  RpcError: errors.RpcError,
+  PaymentError: errors.PaymentError,
+  PaymentUnsupportedError: errors.PaymentUnsupportedError,
+  PaymentRejectedError: errors.PaymentRejectedError,
+  PaymentIndeterminateError: errors.PaymentIndeterminateError,
 };

package/sdk.mjs

@@ -25,6 +25,8 @@ export const {
   WebhooksApiClient,
   KvStoreApiClient,
   SqlApiClient,
+  RpcApiClient,
+  generatePaymentWallet,
   QuicknodeError,
   ConfigError,
   HttpError,
@@ -32,4 +34,9 @@ export const {
   ConnectionError,
   ApiError,
   DecodeError,
+  RpcError,
+  PaymentError,
+  PaymentUnsupportedError,
+  PaymentRejectedError,
+  PaymentIndeterminateError,
 } = cjs;