@quicknode/sdk 3.7.0 → 3.8.1

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()`)
@@ -1727,6 +1741,171 @@ A host that persists across processes can snapshot the cached token with
 `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 or SIWS 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 payment networks use SIWE. Solana payment networks use SIWS with an Ed25519
+signature encoded as Base58. Solana wallets must be funded out of band; the faucet
+is available for Base Sepolia only.
+
+| 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`
@@ -1743,8 +1922,12 @@ subclass to branch on transport vs. API semantics.
 | `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`, `RpcError`. 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

@@ -62,7 +62,40 @@ class RpcError extends QuicknodeError {
   }
 }
 
-const TAG_RE = /^\[(Config|Http|Timeout|Connect|Api|Decode|Rpc)\|([^|]+)\|([^\]]+)\](.*)$/s;
+// 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;
@@ -92,6 +125,9 @@ function fromNapiError(err) {
     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;
   }
 }
@@ -127,6 +163,10 @@ module.exports = {
   ApiError,
   DecodeError,
   RpcError,
+  PaymentError,
+  PaymentUnsupportedError,
+  PaymentRejectedError,
+  PaymentIndeterminateError,
   fromNapiError,
   wrapClient,
 };

package/index.d.ts

@@ -1367,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. */
@@ -1512,6 +1561,19 @@ export interface RpcConfig {
    * 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. */
@@ -1539,7 +1601,17 @@ 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
@@ -2532,6 +2604,13 @@ export declare class RpcApiClient {
    * `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
@@ -2549,6 +2628,79 @@ export declare class RpcApiClient {
    * 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 {
@@ -2744,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.7.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.7.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.1' && 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.1 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.7.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.7.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.1' && 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.1 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.7.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.7.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.1' && 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.1 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.7.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.7.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.1' && 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.1 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.7.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.7.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.1' && 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.1 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.7.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.7.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.1' && 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.1 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.7.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.7.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+      if (bindingPackageVersion !== '3.8.1' && 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.1 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.7.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.7.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.1' && 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.1 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.7.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.7.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.1' && 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.1 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.7.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.7.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.1' && 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.1 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.7.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.7.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.1' && 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.1 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.7.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.7.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '3.8.1' && 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.1 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.7.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.7.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '3.8.1' && 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.1 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.7.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.7.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '3.8.1' && 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.1 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.7.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.7.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '3.8.1' && 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.1 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.7.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.7.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '3.8.1' && 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.1 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.7.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.7.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '3.8.1' && 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.1 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.7.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.7.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '3.8.1' && 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.1 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.7.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.7.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '3.8.1' && 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.1 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.7.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.7.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '3.8.1' && 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.1 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.7.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.7.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '3.8.1' && 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.1 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.7.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.7.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.1' && 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.1 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.7.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.7.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.1' && 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.1 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.7.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.7.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.1' && 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.1 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.7.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.7.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.1' && 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.1 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.7.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.7.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '3.8.1' && 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.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -592,3 +592,4 @@ 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.7.0",
+  "version": "3.8.1",
   "description": "Quicknode SDK",
   "repository": {
     "type": "git",
@@ -54,10 +54,10 @@
   },
   "license": "MIT",
   "optionalDependencies": {
-    "@quicknode/sdk-linux-x64-gnu": "3.7.0",
-    "@quicknode/sdk-linux-arm64-gnu": "3.7.0",
-    "@quicknode/sdk-linux-x64-musl": "3.7.0",
-    "@quicknode/sdk-linux-arm64-musl": "3.7.0",
-    "@quicknode/sdk-darwin-arm64": "3.7.0"
+    "@quicknode/sdk-linux-x64-gnu": "3.8.1",
+    "@quicknode/sdk-linux-arm64-gnu": "3.8.1",
+    "@quicknode/sdk-linux-x64-musl": "3.8.1",
+    "@quicknode/sdk-linux-arm64-musl": "3.8.1",
+    "@quicknode/sdk-darwin-arm64": "3.8.1"
   }
 }

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
@@ -331,8 +332,97 @@ export type {
   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,
@@ -397,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;
@@ -405,7 +550,7 @@ export class QuicknodeSdk {
   webhooks: WebhooksApiClientTyped;
   kvstore: _QuicknodeSdk["kvstore"];
   sql: SqlApiClientTyped;
-  rpc: _QuicknodeSdk["rpc"];
+  rpc: RpcApiClientTyped;
 }
 
 // Typed static factory methods producing each discriminated variant of
@@ -459,3 +604,13 @@ export class DecodeError extends QuicknodeError {
 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

@@ -78,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,
@@ -90,4 +100,8 @@ module.exports = {
   ApiError: errors.ApiError,
   DecodeError: errors.DecodeError,
   RpcError: errors.RpcError,
+  PaymentError: errors.PaymentError,
+  PaymentUnsupportedError: errors.PaymentUnsupportedError,
+  PaymentRejectedError: errors.PaymentRejectedError,
+  PaymentIndeterminateError: errors.PaymentIndeterminateError,
 };

package/sdk.mjs

@@ -26,6 +26,7 @@ export const {
   KvStoreApiClient,
   SqlApiClient,
   RpcApiClient,
+  generatePaymentWallet,
   QuicknodeError,
   ConfigError,
   HttpError,
@@ -34,4 +35,8 @@ export const {
   ApiError,
   DecodeError,
   RpcError,
+  PaymentError,
+  PaymentUnsupportedError,
+  PaymentRejectedError,
+  PaymentIndeterminateError,
 } = cjs;