@txnod/sdk 1.0.1

package/dist/errors.js

@@ -0,0 +1,2107 @@
+import { syntheticDetails } from './internals/synthetic-details.js';
+/**
+ * Base error thrown by every `TxnodClient` method when the server returns a
+ * non-2xx response. Carries the RFC 7807 problem-details envelope so partners
+ * can branch on `error_code` or log `request_id` for support.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10.0,
+ *     coin: 'btc',
+ *     external_id: 'order-123',
+ *     callback_url: 'https://my-site.com/webhooks/txnod',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodError) {
+ *     console.error(err.error_code, err.status, err.request_id);
+ *   } else {
+ *     throw err;
+ *   }
+ * }
+ * ```
+ */
+export class TxnodError extends Error {
+    kind = 'txnod';
+    error_code;
+    status;
+    request_id;
+    raw;
+    constructor(details) {
+        super(details.title);
+        this.name = 'TxnodError';
+        this.error_code = details.error_code;
+        this.status = details.status;
+        this.request_id = details.request_id;
+        this.raw = details;
+    }
+}
+/**
+ * Thrown by `verifyWebhookSignature` when the `X-Txnod-Signature` header is
+ * missing or does not match the expected `t=<unix>,v1=<hex>` shape.
+ *
+ * @example
+ * ```ts
+ * import { verifyWebhookSignature, TxnodSignatureFormatError } from '@txnod/sdk';
+ *
+ * try {
+ *   verifyWebhookSignature(req.headers, rawBody, process.env.TXNOD_WEBHOOK_SECRET!);
+ * } catch (err) {
+ *   if (err instanceof TxnodSignatureFormatError) {
+ *     return new Response('bad header', { status: 401 });
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodSignatureFormatError extends TxnodError {
+    kind = 'signature_format';
+    constructor() {
+        super(syntheticDetails('auth_invalid', 401, 'Webhook signature header is missing or malformed.'));
+        this.name = 'TxnodSignatureFormatError';
+    }
+}
+/**
+ * Thrown by `verifyWebhookSignature` when the computed HMAC-SHA256 does not
+ * match the signature carried in the `X-Txnod-Signature` header.
+ *
+ * @example
+ * ```ts
+ * import { verifyWebhookSignature, TxnodHmacError } from '@txnod/sdk';
+ *
+ * try {
+ *   verifyWebhookSignature(req.headers, rawBody, process.env.TXNOD_WEBHOOK_SECRET!);
+ * } catch (err) {
+ *   if (err instanceof TxnodHmacError) {
+ *     return new Response('bad sig', { status: 401 });
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodHmacError extends TxnodError {
+    kind = 'hmac';
+    constructor() {
+        super(syntheticDetails('signature_invalid', 401, 'Webhook signature does not match.'));
+        this.name = 'TxnodHmacError';
+    }
+}
+/**
+ * Thrown by `verifyWebhookSignature` when the timestamp in the
+ * `X-Txnod-Signature` header is outside the ±300-second window. The signed
+ * `skew_seconds` field reports `now - timestamp` so callers can alert on
+ * clock drift.
+ *
+ * @example
+ * ```ts
+ * import { verifyWebhookSignature, TxnodTimestampError } from '@txnod/sdk';
+ *
+ * try {
+ *   verifyWebhookSignature(req.headers, rawBody, process.env.TXNOD_WEBHOOK_SECRET!);
+ * } catch (err) {
+ *   if (err instanceof TxnodTimestampError) {
+ *     console.warn('clock skew', err.skew_seconds);
+ *     return new Response('stale', { status: 401 });
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodTimestampError extends TxnodError {
+    kind = 'timestamp';
+    skew_seconds;
+    constructor(skewSeconds) {
+        super(syntheticDetails('timestamp_out_of_window', 401, 'Webhook timestamp is outside the ±300-second window.'));
+        this.name = 'TxnodTimestampError';
+        this.skew_seconds = skewSeconds;
+    }
+}
+/**
+ * Thrown by `verifyWebhookSignature` when the body bytes pass HMAC verification
+ * but cannot be parsed as JSON. In a non-compromised setup this never fires;
+ * a real occurrence indicates a misbehaving server release that emitted a
+ * non-JSON body alongside a valid signature. The `cause` field carries the
+ * underlying `SyntaxError` so the partner can log it. Treat it as a 401-class
+ * failure (do not parse, do not act) — same handling as `TxnodHmacError`.
+ *
+ * @example
+ * ```ts
+ * import { verifyWebhookSignature, TxnodWebhookPayloadParseError } from '@txnod/sdk';
+ *
+ * try {
+ *   verifyWebhookSignature(req.headers, rawBody, secret);
+ * } catch (err) {
+ *   if (err instanceof TxnodWebhookPayloadParseError) {
+ *     return new Response('bad payload', { status: 401 });
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodWebhookPayloadParseError extends TxnodError {
+    kind = 'webhook_payload_parse';
+    cause;
+    constructor(cause) {
+        super(syntheticDetails('internal_error', 401, 'Webhook body passed HMAC but is not valid JSON.'));
+        this.name = 'TxnodWebhookPayloadParseError';
+        this.cause = cause;
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'validation_error'` —
+ * request payload failed validation (Zod on the server). Inspect
+ * `err.raw.errors` for the structured per-field issues.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodValidationError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10,
+ *     coin: 'btc',
+ *     external_id: 'order-1',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodValidationError) {
+ *     console.error('validation failed:', err.raw.errors);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodValidationError extends TxnodError {
+    kind = 'validation_error';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodValidationError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'invalid_coin'` — the
+ * requested `coin` is not in the supported coins enum.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodInvalidCoinError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10,
+ *     coin: 'btc',
+ *     external_id: 'order-1',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodInvalidCoinError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodInvalidCoinError extends TxnodError {
+    kind = 'invalid_coin';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodInvalidCoinError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'invalid_xpub_format'` —
+ * the supplied xpub string is structurally invalid for the chain.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodInvalidXpubFormatError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodInvalidXpubFormatError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodInvalidXpubFormatError extends TxnodError {
+    kind = 'invalid_xpub_format';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodInvalidXpubFormatError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'invalid_webhook_url'` —
+ * the configured webhook URL is not a valid https URL.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodInvalidWebhookUrlError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodInvalidWebhookUrlError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodInvalidWebhookUrlError extends TxnodError {
+    kind = 'invalid_webhook_url';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodInvalidWebhookUrlError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'auth_invalid'` on an API
+ * call — the `X-Project-Id` / `X-Signature` headers are missing, malformed,
+ * or do not identify a known project. Distinct from the webhook-local
+ * `TxnodSignatureFormatError`: this one is thrown by `TxnodClient` methods
+ * on an API 401 response.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodAuthInvalidError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodAuthInvalidError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodAuthInvalidError extends TxnodError {
+    kind = 'auth_invalid';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodAuthInvalidError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'signature_invalid'` on
+ * an API call — the computed HMAC for the outbound request did not match.
+ * Distinct from the webhook-local `TxnodHmacError`.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodSignatureInvalidError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodSignatureInvalidError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodSignatureInvalidError extends TxnodError {
+    kind = 'signature_invalid';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodSignatureInvalidError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'signature_replayed'` —
+ * the same signed `(timestamp, signature)` triple has already been processed
+ * within the freshness window. Re-sign the request (fresh timestamp) and try
+ * again. Persistent occurrence indicates a stuck retry loop on the caller
+ * side or, rarer, replay of a captured request.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodSignatureReplayedError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10,
+ *     coin: 'btc',
+ *     external_id: 'order-1',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodSignatureReplayedError) {
+ *     // The previous attempt's signature was already accepted. The SDK
+ *     // signs every request with a fresh timestamp, so this normally only
+ *     // surfaces when something else (a proxy, a retry loop) sends the
+ *     // exact same signed bytes a second time.
+ *     console.error('signed request already processed', err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodSignatureReplayedError extends TxnodError {
+    kind = 'signature_replayed';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodSignatureReplayedError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'timestamp_out_of_window'`
+ * on an API call — the `X-Timestamp` header is outside the ±300-second
+ * window. Distinct from the webhook-local `TxnodTimestampError`, which
+ * exposes a `skew_seconds` field.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodTimestampOutOfWindowError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodTimestampOutOfWindowError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodTimestampOutOfWindowError extends TxnodError {
+    kind = 'timestamp_out_of_window';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodTimestampOutOfWindowError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'key_suspended'` — the
+ * owner of the API key has been suspended.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodKeySuspendedError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodKeySuspendedError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodKeySuspendedError extends TxnodError {
+    kind = 'key_suspended';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodKeySuspendedError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'project_suspended'` —
+ * the target project has been suspended.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodProjectSuspendedError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodProjectSuspendedError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodProjectSuspendedError extends TxnodError {
+    kind = 'project_suspended';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodProjectSuspendedError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'permission_denied'` —
+ * the authenticated key does not hold the capability required by the route.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodPermissionDeniedError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodPermissionDeniedError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodPermissionDeniedError extends TxnodError {
+    kind = 'permission_denied';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodPermissionDeniedError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'key_revoked'` — the
+ * API key has been rotated or revoked and is no longer valid.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodKeyRevokedError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodKeyRevokedError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodKeyRevokedError extends TxnodError {
+    kind = 'key_revoked';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodKeyRevokedError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'invoice_not_found'` —
+ * no invoice exists with the given id for this project.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodInvoiceNotFoundError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   return Response.json(invoice);
+ * } catch (err) {
+ *   if (err instanceof TxnodInvoiceNotFoundError) {
+ *     return new Response('Not found', { status: 404 });
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodInvoiceNotFoundError extends TxnodError {
+    kind = 'invoice_not_found';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodInvoiceNotFoundError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'project_not_found'` —
+ * no project exists with the given id (or the key does not have access).
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodProjectNotFoundError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodProjectNotFoundError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodProjectNotFoundError extends TxnodError {
+    kind = 'project_not_found';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodProjectNotFoundError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'wallet_not_found'` —
+ * no wallet record exists for the requested chain + project.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodWalletNotFoundError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodWalletNotFoundError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodWalletNotFoundError extends TxnodError {
+    kind = 'wallet_not_found';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodWalletNotFoundError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'external_id_conflict'` —
+ * an invoice with the requested `external_id` already exists for this
+ * project. Treat as idempotent success and fetch the existing invoice.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodExternalIdConflictError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10,
+ *     coin: 'btc',
+ *     external_id: 'order-1',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodExternalIdConflictError) {
+ *     const page = await client.searchInvoices({ external_id: 'order-1', limit: 1 });
+ *     const existing = page.items[0];
+ *     if (existing !== undefined) console.log(existing.status);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodExternalIdConflictError extends TxnodError {
+    kind = 'external_id_conflict';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodExternalIdConflictError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'xpub_not_verified'` —
+ * the xpub for the chain has not completed its verification challenge yet.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodXpubNotVerifiedError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10,
+ *     coin: 'btc',
+ *     external_id: 'order-1',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodXpubNotVerifiedError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodXpubNotVerifiedError extends TxnodError {
+    kind = 'xpub_not_verified';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodXpubNotVerifiedError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'coin_not_enabled'` —
+ * the requested coin is not enabled for this project. Point the user at a
+ * coin from `client.getRates()`.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodCoinNotEnabledError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10,
+ *     coin: 'btc',
+ *     external_id: 'order-1',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodCoinNotEnabledError) {
+ *     const rates = await client.getRates({});
+ *     console.log('enabled coins:', Object.keys(rates.rates));
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodCoinNotEnabledError extends TxnodError {
+    kind = 'coin_not_enabled';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodCoinNotEnabledError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'amount_out_of_range'` —
+ * the requested amount is outside the project's accepted range.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodAmountOutOfRangeError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10,
+ *     coin: 'btc',
+ *     external_id: 'order-1',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodAmountOutOfRangeError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodAmountOutOfRangeError extends TxnodError {
+    kind = 'amount_out_of_range';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodAmountOutOfRangeError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'rate_limit_exceeded'` —
+ * the per-key rate limit has been exceeded. The `retry_after_seconds` field
+ * carries the value of the HTTP `Retry-After` header (0 when absent).
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodRateLimitError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodRateLimitError) {
+ *     await new Promise((r) => setTimeout(r, err.retry_after_seconds * 1000));
+ *     const retry = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *     console.log(retry.status);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodRateLimitError extends TxnodError {
+    kind = 'rate_limit_exceeded';
+    retry_after_seconds;
+    constructor(details, retryAfterSeconds) {
+        super(details);
+        this.name = 'TxnodRateLimitError';
+        this.retry_after_seconds = retryAfterSeconds;
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'pool_exhausted'` — the
+ * per-chain derivation-address pool has hit its hard cap
+ * (`poolSizePerChain[chain]`) and no slot is currently `available`. The
+ * `retry_after_seconds` field carries the value of the HTTP `Retry-After`
+ * header (0 when absent) — the server derives it from the soonest
+ * `locked_until` across locked rows, falling back to the project's
+ * `cooldownSeconds`. Wait the indicated interval before retrying, or raise
+ * the per-chain pool cap if this fires under normal load.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodPoolExhaustedError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10,
+ *     coin: 'btc',
+ *     external_id: 'order-1',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodPoolExhaustedError) {
+ *     await new Promise((r) => setTimeout(r, err.retry_after_seconds * 1000));
+ *     const retry = await client.createInvoice({
+ *       amount_usd: 10,
+ *       coin: 'btc',
+ *       external_id: 'order-1',
+ *     });
+ *     console.log(retry.id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodPoolExhaustedError extends TxnodError {
+    kind = 'pool_exhausted';
+    retry_after_seconds;
+    constructor(details, retryAfterSeconds) {
+        super(details);
+        this.name = 'TxnodPoolExhaustedError';
+        this.retry_after_seconds = retryAfterSeconds;
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'webhook_capacity_exhausted'`
+ * — the chain's webhook fleet has no spare slots, so the server can't bind a
+ * new pool address to a webhook. `retry_after_seconds` is `0` because partner
+ * retry alone will not free capacity. Treat as a transient outage; queue the
+ * invoice and retry later.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodWebhookCapacityExhaustedError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   await client.createInvoice({
+ *     external_id: 'order-1',
+ *     amount_usd: 100,
+ *     coin: 'eth',
+ *   });
+ * } catch (err) {
+ *   if (err instanceof TxnodWebhookCapacityExhaustedError) {
+ *     console.error('webhook fleet at capacity for chain:', err.kind);
+ *     // Transient outage — queue invoice and retry later.
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodWebhookCapacityExhaustedError extends TxnodError {
+    kind = 'webhook_capacity_exhausted';
+    retry_after_seconds;
+    constructor(details, retryAfterSeconds) {
+        super(details);
+        this.name = 'TxnodWebhookCapacityExhaustedError';
+        this.retry_after_seconds = retryAfterSeconds;
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'internal_error'` — the
+ * server failed for a reason it could not categorize. Log `err.request_id`
+ * for support and treat as a retryable 5xx.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodServerError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodServerError) {
+ *     console.error('TxNod server error — report request_id to support:', err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodServerError extends TxnodError {
+    kind = 'internal_error';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodServerError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'invoice_not_cancellable'`
+ * — the invoice is in a state that does not permit cancellation.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodInvoiceNotCancellableError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.cancelInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodInvoiceNotCancellableError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodInvoiceNotCancellableError extends TxnodError {
+    kind = 'invoice_not_cancellable';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodInvoiceNotCancellableError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'invalid_state_transition'`
+ * — the requested operation would produce an illegal invoice state
+ * transition.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodInvalidStateTransitionError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.cancelInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodInvalidStateTransitionError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodInvalidStateTransitionError extends TxnodError {
+    kind = 'invalid_state_transition';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodInvalidStateTransitionError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'orphan_not_found'` —
+ * no orphan payment exists with the given tx hash.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodOrphanNotFoundError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   await client.attributeOrphanPayment('0xabc', { external_id: 'order-1' });
+ * } catch (err) {
+ *   if (err instanceof TxnodOrphanNotFoundError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodOrphanNotFoundError extends TxnodError {
+    kind = 'orphan_not_found';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodOrphanNotFoundError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'orphan_already_attributed'`
+ * — the orphan payment has already been attributed to an invoice.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodOrphanAlreadyAttributedError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   await client.attributeOrphanPayment('0xabc', { external_id: 'order-1' });
+ * } catch (err) {
+ *   if (err instanceof TxnodOrphanAlreadyAttributedError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodOrphanAlreadyAttributedError extends TxnodError {
+    kind = 'orphan_already_attributed';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodOrphanAlreadyAttributedError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'event_not_found'` — no
+ * webhook event exists with the given id for this project.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodEventNotFoundError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   await client.resendWebhookEvent('01HK8MAR2QEXAMPLE000000000');
+ * } catch (err) {
+ *   if (err instanceof TxnodEventNotFoundError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodEventNotFoundError extends TxnodError {
+    kind = 'event_not_found';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodEventNotFoundError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'wallet_not_bound'` —
+ * the target project has no verified wallet bound for the requested chain.
+ * The chain is implied by the invoice's `coin` and the project's `kind`
+ * (production / testnet) is fixed at project create time. Bind a wallet of
+ * matching kind via the dashboard or the binding API before retrying invoice
+ * creation.
+ *
+ * Status: 422 (was 409 in pre-`testnet`-kind builds).
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodWalletNotBoundError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10,
+ *     coin: 'btc',
+ *     external_id: 'order-1',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodWalletNotBoundError) {
+ *     console.error('bind a wallet before retrying', err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodWalletNotBoundError extends TxnodError {
+    kind = 'wallet_not_bound';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodWalletNotBoundError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'wallet_kind_mismatch'`
+ * (HTTP 422) — the operator attempted to bind an `operator_wallet` of one
+ * `kind` (e.g. `'testnet'`) to a project of a different `kind` (e.g.
+ * `'production'`). Project kind is fixed at create time and cross-kind
+ * binding is forbidden — production projects accept only production wallets,
+ * testnet projects accept only testnet wallets, sandbox projects auto-derive
+ * their own simulated wallets and never reach the operator-binding surface.
+ *
+ * Recover by either creating a wallet of the matching kind, or creating a
+ * fresh project of the wallet's kind.
+ *
+ * @example
+ * ```ts
+ * import { TxnodWalletKindMismatchError } from '@txnod/sdk';
+ *
+ * try {
+ *   // ...attempt a cross-kind wallet binding via a server action / internal API...
+ * } catch (err) {
+ *   if (err instanceof TxnodWalletKindMismatchError) {
+ *     console.error('cannot bind across kinds', err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodWalletKindMismatchError extends TxnodError {
+    kind = 'wallet_kind_mismatch';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodWalletKindMismatchError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'wallet_not_owned'` — the
+ * authenticated operator does not own the wallet targeted by the request.
+ * Dashboard-only: the partner HMAC surface never exposes other-operator wallets,
+ * so this error is limited to internal Server Actions.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodWalletNotOwnedError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodWalletNotOwnedError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodWalletNotOwnedError extends TxnodError {
+    kind = 'wallet_not_owned';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodWalletNotOwnedError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'wallet_has_active_bindings'`
+ * — the authenticated operator attempted to archive an `operator_wallet` while
+ * at least one `project_chain_wallet_bindings` row still references it. The
+ * RFC-7807 response carries an `extensions.affected_projects` list of
+ * `(project_id, project_name, chain)` tuples; future SDK methods will expose
+ * them via a dedicated field on this class.
+ *
+ * @example
+ * ```ts
+ * import { TxnodWalletHasActiveBindingsError } from '@txnod/sdk';
+ *
+ * try {
+ *   // ...attempt to archive an operator wallet that still has active bindings...
+ * } catch (err) {
+ *   if (err instanceof TxnodWalletHasActiveBindingsError) {
+ *     console.error('rebind affected projects first', err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodWalletHasActiveBindingsError extends TxnodError {
+    kind = 'wallet_has_active_bindings';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodWalletHasActiveBindingsError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'subscription_expired'`
+ * (HTTP 402) — the authenticated operator's subscription is not `active`
+ * and write operations are blocked. Reads remain available. The operator
+ * must renew via `/billing` before writes will succeed again.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodSubscriptionExpiredError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   await client.createInvoice({ external_id: 'o-1', amount_usd: 50, coin: 'btc' });
+ * } catch (err) {
+ *   if (err instanceof TxnodSubscriptionExpiredError) {
+ *     console.error('renew subscription at /billing', err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodSubscriptionExpiredError extends TxnodError {
+    kind = 'subscription_expired';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodSubscriptionExpiredError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'tron_no_activated_addresses_available'`
+ * (HTTP 422) — the operator's TRON pool has zero activated addresses and the
+ * invoice cannot be issued. The `wallet_id` field carries the operator wallet
+ * id; deep-link the operator into `/wallets/{wallet_id}` where they can
+ * activate addresses via a third-party multisend service or an in-dashboard
+ * Ledger tool.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodTronNoActivatedAddressesError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10,
+ *     coin: 'usdt_trc20',
+ *     external_id: 'order-1',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodTronNoActivatedAddressesError) {
+ *     console.error('activate addresses for wallet', err.walletId);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodTronNoActivatedAddressesError extends TxnodError {
+    kind = 'tron_no_activated_addresses_available';
+    walletId;
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodTronNoActivatedAddressesError';
+        if (typeof details.wallet_id !== 'string' || details.wallet_id.length === 0) {
+            throw new Error('TxnodTronNoActivatedAddressesError: wallet_id is required on the problem-details body');
+        }
+        this.walletId = details.wallet_id;
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'ton_operator_wallet_not_deployed'`
+ * (HTTP 422) — the operator's TON wallet has not yet been deployed on-chain,
+ * so a deposit cannot be issued. Trigger the wallet's first outbound message
+ * (or send a no-op transaction) to deploy the contract, then retry.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodTonOperatorWalletNotDeployedError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10,
+ *     coin: 'ton',
+ *     external_id: 'order-1',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodTonOperatorWalletNotDeployedError) {
+ *     console.error('deploy operator wallet before issuing TON invoices', err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodTonOperatorWalletNotDeployedError extends TxnodError {
+    kind = 'ton_operator_wallet_not_deployed';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodTonOperatorWalletNotDeployedError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'ton_invalid_wallet_version'`
+ * (HTTP 422) — the TON wallet version supplied is not one of the supported
+ * versions (`v3R2`, `v4R2`, `v5R1`).
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodTonInvalidWalletVersionError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10,
+ *     coin: 'ton',
+ *     external_id: 'order-1',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodTonInvalidWalletVersionError) {
+ *     console.error('register a v3R2/v4R2/v5R1 wallet', err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodTonInvalidWalletVersionError extends TxnodError {
+    kind = 'ton_invalid_wallet_version';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodTonInvalidWalletVersionError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'ton_jetton_resolve_failed'`
+ * (HTTP 503) — the TON jetton-wallet address could not be resolved because
+ * the upstream provider is temporarily unavailable. The error is retryable.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodTonJettonResolveFailedError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10,
+ *     coin: 'usdt_ton',
+ *     external_id: 'order-1',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodTonJettonResolveFailedError) {
+ *     console.error('jetton resolver unavailable; retrying soon', err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodTonJettonResolveFailedError extends TxnodError {
+    kind = 'ton_jetton_resolve_failed';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodTonJettonResolveFailedError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'ton_comment_parse_failed'`
+ * (HTTP 422) — a TON deposit comment could not be parsed as a payment token.
+ * Surfaces through the orphan / unattributed-deposit flow rather than the
+ * partner integration API, but is included here for SDK error mapping
+ * completeness.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodTonCommentParseFailedError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   await client.attributeOrphanPayment('0xabc', { external_id: 'order-1' });
+ * } catch (err) {
+ *   if (err instanceof TxnodTonCommentParseFailedError) {
+ *     console.error('TON deposit comment was unparseable', err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodTonCommentParseFailedError extends TxnodError {
+    kind = 'ton_comment_parse_failed';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodTonCommentParseFailedError';
+    }
+}
+// TON Connect /payload + /verify error classes — produced by
+// `/api/internal/wallets/tonconnect/*` and flowed through the generic
+// `parseProblemDetails` mapper.
+/**
+ * Thrown when the dashboard responds with `error_code: 'tonconnect_payload_expired'`.
+ * The TON Connect handshake nonce expired (5-minute TTL); restart the wizard.
+ *
+ * @example
+ * ```ts
+ * import { TxnodTonConnectPayloadExpiredError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call that bubbles a /tonconnect/verify problem+json
+ * } catch (err) {
+ *   if (err instanceof TxnodTonConnectPayloadExpiredError) {
+ *     console.error('TON Connect nonce expired', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export class TxnodTonConnectPayloadExpiredError extends TxnodError {
+    kind = 'tonconnect_payload_expired';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodTonConnectPayloadExpiredError';
+    }
+}
+/**
+ * Thrown when the dashboard responds with `error_code: 'tonconnect_payload_unknown'`.
+ * The proof's payload field does not match any nonce on file for this operator.
+ *
+ * @example
+ * ```ts
+ * import { TxnodTonConnectPayloadUnknownError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call that bubbles a /tonconnect/verify problem+json
+ * } catch (err) {
+ *   if (err instanceof TxnodTonConnectPayloadUnknownError) {
+ *     console.error('TON Connect nonce unknown', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export class TxnodTonConnectPayloadUnknownError extends TxnodError {
+    kind = 'tonconnect_payload_unknown';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodTonConnectPayloadUnknownError';
+    }
+}
+/**
+ * Thrown when the dashboard responds with `error_code: 'tonconnect_domain_mismatch'`.
+ * The wallet attested to a different domain than the server's TXNOD_TONCONNECT_DOMAIN.
+ *
+ * @example
+ * ```ts
+ * import { TxnodTonConnectDomainMismatchError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call that bubbles a /tonconnect/verify problem+json
+ * } catch (err) {
+ *   if (err instanceof TxnodTonConnectDomainMismatchError) {
+ *     console.error('TON Connect domain mismatch', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export class TxnodTonConnectDomainMismatchError extends TxnodError {
+    kind = 'tonconnect_domain_mismatch';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodTonConnectDomainMismatchError';
+    }
+}
+/**
+ * Thrown when the dashboard responds with `error_code: 'tonconnect_timestamp_skew'`.
+ * The proof timestamp is outside the 5-minute / +60s acceptance window.
+ *
+ * @example
+ * ```ts
+ * import { TxnodTonConnectTimestampSkewError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call that bubbles a /tonconnect/verify problem+json
+ * } catch (err) {
+ *   if (err instanceof TxnodTonConnectTimestampSkewError) {
+ *     console.error('TON Connect timestamp skew', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export class TxnodTonConnectTimestampSkewError extends TxnodError {
+    kind = 'tonconnect_timestamp_skew';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodTonConnectTimestampSkewError';
+    }
+}
+/**
+ * Thrown when the dashboard responds with `error_code: 'tonconnect_unknown_wallet_version'`.
+ * The wallet's `walletStateInit` does not match any known TON wallet version.
+ *
+ * @example
+ * ```ts
+ * import { TxnodTonConnectUnknownWalletVersionError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call that bubbles a /tonconnect/verify problem+json
+ * } catch (err) {
+ *   if (err instanceof TxnodTonConnectUnknownWalletVersionError) {
+ *     console.error('TON Connect unknown wallet version', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export class TxnodTonConnectUnknownWalletVersionError extends TxnodError {
+    kind = 'tonconnect_unknown_wallet_version';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodTonConnectUnknownWalletVersionError';
+    }
+}
+/**
+ * Thrown when the dashboard responds with `error_code: 'tonconnect_signature_invalid'`.
+ * The Ed25519 verification of the ton_proof signature failed.
+ *
+ * @example
+ * ```ts
+ * import { TxnodTonConnectSignatureInvalidError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call that bubbles a /tonconnect/verify problem+json
+ * } catch (err) {
+ *   if (err instanceof TxnodTonConnectSignatureInvalidError) {
+ *     console.error('TON Connect proof rejected', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export class TxnodTonConnectSignatureInvalidError extends TxnodError {
+    kind = 'tonconnect_signature_invalid';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodTonConnectSignatureInvalidError';
+    }
+}
+/**
+ * Thrown when the dashboard responds with `error_code: 'tonconnect_network_mismatch'`.
+ * The wallet reported a chain id (`-239`/`-3`) that disagrees with the wizard's network.
+ *
+ * @example
+ * ```ts
+ * import { TxnodTonConnectNetworkMismatchError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call that bubbles a /tonconnect/verify problem+json
+ * } catch (err) {
+ *   if (err instanceof TxnodTonConnectNetworkMismatchError) {
+ *     console.error('TON Connect network mismatch', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export class TxnodTonConnectNetworkMismatchError extends TxnodError {
+    kind = 'tonconnect_network_mismatch';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodTonConnectNetworkMismatchError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'sandbox_project_required'`.
+ * The endpoint accepts only sandbox projects and the targeted project's `kind`
+ * is `production`. Story 37.3 will surface a richer SDK surface.
+ *
+ * @example
+ * ```ts
+ * import { TxnodSandboxProjectRequiredError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call that targets a sandbox-only endpoint
+ * } catch (err) {
+ *   if (err instanceof TxnodSandboxProjectRequiredError) {
+ *     console.error('Sandbox-only endpoint', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export class TxnodSandboxProjectRequiredError extends TxnodError {
+    kind = 'sandbox_project_required';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodSandboxProjectRequiredError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'production_project_required'`.
+ * The endpoint accepts only production projects and the targeted project's
+ * `kind` is `sandbox` or `testnet`.
+ *
+ * @example
+ * ```ts
+ * import { TxnodProductionProjectRequiredError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call that targets a production-only endpoint
+ * } catch (err) {
+ *   if (err instanceof TxnodProductionProjectRequiredError) {
+ *     console.error('Production-only endpoint', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export class TxnodProductionProjectRequiredError extends TxnodError {
+    kind = 'production_project_required';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodProductionProjectRequiredError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'sandbox_per_operator_cap_reached'`.
+ * The operator already has the maximum number of active sandbox projects.
+ *
+ * @example
+ * ```ts
+ * import { TxnodSandboxPerOperatorCapReachedError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call that creates a new sandbox project
+ * } catch (err) {
+ *   if (err instanceof TxnodSandboxPerOperatorCapReachedError) {
+ *     console.error('sandbox cap reached', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export class TxnodSandboxPerOperatorCapReachedError extends TxnodError {
+    kind = 'sandbox_per_operator_cap_reached';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodSandboxPerOperatorCapReachedError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'sandbox_key_against_production_project'`.
+ * A sandbox API key (prefix `sk_sandbox_`) was used against a production project.
+ *
+ * @example
+ * ```ts
+ * import { TxnodSandboxKeyAgainstProductionProjectError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call with mixed-mode credentials
+ * } catch (err) {
+ *   if (err instanceof TxnodSandboxKeyAgainstProductionProjectError) {
+ *     console.error('cross-mode rejected', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export class TxnodSandboxKeyAgainstProductionProjectError extends TxnodError {
+    kind = 'sandbox_key_against_production_project';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodSandboxKeyAgainstProductionProjectError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'production_key_against_sandbox_project'`.
+ * A production API key was used against a sandbox project.
+ *
+ * @example
+ * ```ts
+ * import { TxnodProductionKeyAgainstSandboxProjectError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call with mixed-mode credentials
+ * } catch (err) {
+ *   if (err instanceof TxnodProductionKeyAgainstSandboxProjectError) {
+ *     console.error('cross-mode rejected', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export class TxnodProductionKeyAgainstSandboxProjectError extends TxnodError {
+    kind = 'production_key_against_sandbox_project';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodProductionKeyAgainstSandboxProjectError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'sandbox_provisioning_failed'`.
+ * The sandbox project could not be provisioned (transient or internal error).
+ *
+ * @example
+ * ```ts
+ * import { TxnodSandboxProvisioningFailedError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call that creates a new sandbox project
+ * } catch (err) {
+ *   if (err instanceof TxnodSandboxProvisioningFailedError) {
+ *     console.error('sandbox provisioning failed', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export class TxnodSandboxProvisioningFailedError extends TxnodError {
+    kind = 'sandbox_provisioning_failed';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodSandboxProvisioningFailedError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'sandbox_invoice_transition_invalid'`.
+ * A simulate-* call requested a state-machine transition forbidden by the
+ * invoice's current status. Story 37.3 will surface a richer SDK surface.
+ *
+ * @example
+ * ```ts
+ * import { TxnodSandboxInvoiceTransitionInvalidError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call into a sandbox simulate-* endpoint
+ * } catch (err) {
+ *   if (err instanceof TxnodSandboxInvoiceTransitionInvalidError) {
+ *     console.error('forbidden transition', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export class TxnodSandboxInvoiceTransitionInvalidError extends TxnodError {
+    kind = 'sandbox_invoice_transition_invalid';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodSandboxInvoiceTransitionInvalidError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'sandbox_invoice_not_found'`.
+ *
+ * @example
+ * ```ts
+ * import { TxnodSandboxInvoiceNotFoundError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call into a sandbox simulate-* endpoint
+ * } catch (err) {
+ *   if (err instanceof TxnodSandboxInvoiceNotFoundError) {
+ *     console.error('sandbox invoice missing', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export class TxnodSandboxInvoiceNotFoundError extends TxnodError {
+    kind = 'sandbox_invoice_not_found';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodSandboxInvoiceNotFoundError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'sandbox_invoice_terminal'`.
+ *
+ * @example
+ * ```ts
+ * import { TxnodSandboxInvoiceTerminalError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call into a sandbox simulate-* endpoint
+ * } catch (err) {
+ *   if (err instanceof TxnodSandboxInvoiceTerminalError) {
+ *     console.error('invoice already terminal', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export class TxnodSandboxInvoiceTerminalError extends TxnodError {
+    kind = 'sandbox_invoice_terminal';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodSandboxInvoiceTerminalError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'sandbox_rate_limit_exceeded'`.
+ *
+ * @example
+ * ```ts
+ * import { TxnodSandboxRateLimitExceededError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call into a sandbox simulate-* endpoint
+ * } catch (err) {
+ *   if (err instanceof TxnodSandboxRateLimitExceededError) {
+ *     console.error('sandbox rate limited', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export class TxnodSandboxRateLimitExceededError extends TxnodError {
+    kind = 'sandbox_rate_limit_exceeded';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodSandboxRateLimitExceededError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'sandbox_reset_failed'`.
+ *
+ * @example
+ * ```ts
+ * import { TxnodSandboxResetFailedError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call to /api/v1/sandbox/{projectId}/reset
+ * } catch (err) {
+ *   if (err instanceof TxnodSandboxResetFailedError) {
+ *     console.error('sandbox reset failed', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export class TxnodSandboxResetFailedError extends TxnodError {
+    kind = 'sandbox_reset_failed';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodSandboxResetFailedError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'sandbox_delete_failed'`.
+ *
+ * @example
+ * ```ts
+ * import { TxnodSandboxDeleteFailedError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call to DELETE /api/v1/sandbox/{projectId}
+ * } catch (err) {
+ *   if (err instanceof TxnodSandboxDeleteFailedError) {
+ *     console.error('sandbox delete failed', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export class TxnodSandboxDeleteFailedError extends TxnodError {
+    kind = 'sandbox_delete_failed';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodSandboxDeleteFailedError';
+    }
+}
+/**
+ * Thrown when the server responds with `error_code: 'sandbox_active_invoice_cap_reached'`.
+ *
+ * @example
+ * ```ts
+ * import { TxnodSandboxActiveInvoiceCapReachedError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call into POST /api/v1/invoices for a sandbox project
+ * } catch (err) {
+ *   if (err instanceof TxnodSandboxActiveInvoiceCapReachedError) {
+ *     console.error('sandbox active-invoice cap reached', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export class TxnodSandboxActiveInvoiceCapReachedError extends TxnodError {
+    kind = 'sandbox_active_invoice_cap_reached';
+    constructor(details) {
+        super(details);
+        this.name = 'TxnodSandboxActiveInvoiceCapReachedError';
+    }
+}
+/**
+ * Thrown synchronously by the `TxnodClient` constructor when the configured
+ * `apiSecret` carries the `sk_sandbox_` prefix AND `getSdkEnv()` resolves to
+ * `'production'` AND the `iAcknowledgeRoutingRealCustomerFundsToSandboxAddresses`
+ * override is not set or `false`.
+ *
+ * The error names which signal triggered the production detection so the
+ * operator can fix the configuration source. Boot fails — no client instance
+ * is returned.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodSandboxKeyInProductionError } from '@txnod/sdk';
+ *
+ * try {
+ *   const client = new TxnodClient({
+ *     projectId: process.env.TXNOD_PROJECT_ID!,
+ *     apiSecret: process.env.TXNOD_API_SECRET!,
+ *   });
+ *   void client;
+ * } catch (err) {
+ *   if (err instanceof TxnodSandboxKeyInProductionError) {
+ *     console.error(
+ *       'sandbox secret in production environment',
+ *       err.signal,
+ *       err.secretPrefix,
+ *     );
+ *     process.exit(1);
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodSandboxKeyInProductionError extends TxnodError {
+    kind = 'sandbox_key_in_production';
+    secretPrefix;
+    detectedEnvironment;
+    signal;
+    constructor(signal) {
+        super(syntheticDetails('auth_invalid', 401, `Sandbox API secret (sk_sandbox_*) detected in production environment via ${signal}. Refusing to construct TxnodClient. Set iAcknowledgeRoutingRealCustomerFundsToSandboxAddresses: true to override.`));
+        this.name = 'TxnodSandboxKeyInProductionError';
+        this.secretPrefix = 'sk_sandbox_';
+        this.detectedEnvironment = 'production';
+        this.signal = signal;
+    }
+}
+/**
+ * Thrown synchronously by the `TxnodClient` constructor when the configured
+ * `apiSecret` carries the `sk_sandbox_` prefix AND `getSdkEnv()` returns
+ * `'unknown'` (no signal indicates whether the runtime is production).
+ *
+ * The fix: set the `environment` constructor option, the
+ * `TXNOD_ENVIRONMENT` env var, or `NODE_ENV` to a recognised value.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodEnvironmentUnknownError } from '@txnod/sdk';
+ *
+ * try {
+ *   const client = new TxnodClient({
+ *     projectId: process.env.TXNOD_PROJECT_ID!,
+ *     apiSecret: process.env.TXNOD_API_SECRET!,
+ *     environment: 'non-production',
+ *   });
+ *   void client;
+ * } catch (err) {
+ *   if (err instanceof TxnodEnvironmentUnknownError) {
+ *     console.error('environment unknown for sandbox secret', err.message);
+ *     process.exit(1);
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodEnvironmentUnknownError extends TxnodError {
+    kind = 'environment_unknown';
+    constructor() {
+        super(syntheticDetails('auth_invalid', 401, 'Sandbox API secret (sk_sandbox_*) detected but environment is unknown. Set the `environment` constructor option, TXNOD_ENVIRONMENT, or NODE_ENV.'));
+        this.name = 'TxnodEnvironmentUnknownError';
+    }
+}
+/**
+ * Thrown synchronously by the `TxnodClient` constructor (and at
+ * `refreshXpubConfig()` time) when one of the configured xpubs has a
+ * testnet-shape prefix (`tpub`/`vpub`/`upub`) AND `getSdkEnv()` returns
+ * `'production'`.
+ *
+ * Carve-outs documented on `assertNoTestnetXpubsInProduction`:
+ *  - Cardano (CIP-5 hrp does not distinguish testnet at account-pubkey level —
+ *    safety lives at the address-level NetworkId byte; guard is a no-op).
+ *  - TON (no xpub concept; guard is a no-op).
+ *  - EVM mainnet/testnet `xpub` ambiguity — testnet differentiation lives in
+ *    the address checksum, not the xpub itself; only `tpub`/`vpub`/`upub`
+ *    prefixes are reliably classified as testnet.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodSandboxXpubInProductionError } from '@txnod/sdk';
+ *
+ * try {
+ *   const client = new TxnodClient({
+ *     projectId: process.env.TXNOD_PROJECT_ID!,
+ *     apiSecret: process.env.TXNOD_API_SECRET!,
+ *   });
+ *   void client;
+ * } catch (err) {
+ *   if (err instanceof TxnodSandboxXpubInProductionError) {
+ *     console.error(
+ *       'testnet xpub in production',
+ *       err.chain,
+ *       err.xpubPrefix,
+ *     );
+ *     process.exit(1);
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export class TxnodSandboxXpubInProductionError extends TxnodError {
+    kind = 'sandbox_xpub_in_production';
+    chain;
+    xpubPrefix;
+    detectedEnvironment;
+    constructor(chain, xpubPrefix) {
+        super(syntheticDetails('auth_invalid', 401, `Testnet-shape xpub prefix '${xpubPrefix}' configured for chain '${chain}' in production environment. Refusing to construct TxnodClient.`));
+        this.name = 'TxnodSandboxXpubInProductionError';
+        this.chain = chain;
+        this.xpubPrefix = xpubPrefix;
+        this.detectedEnvironment = 'production';
+    }
+}
+//# sourceMappingURL=errors.js.map