@mystars-tg/faas-sdk 0.1.2

package/dist/index.d.cts

@@ -0,0 +1,1038 @@
+/**
+ * Wire types for the MyStars FaaS `/v1` API.
+ *
+ * These mirror the JSON the server actually returns, field-for-field, in
+ * `snake_case` — so they read identically to the REST docs. Money is always a
+ * decimal string (never a `number`); convert to smallest units only at the
+ * on-chain boundary.
+ */
+/** On-chain payment currency. Both settle on the TON chain. */
+type Currency = "ton" | "usdt_ton";
+/** Orderable product type. */
+type OrderType = "stars" | "premium";
+/** Which numeric parameter a product is sized by. */
+type Parameter = "quantity" | "months";
+/** The full FaaS order status domain (15 values). */
+type OrderStatus = "received" | "awaiting_payment" | "paid" | "reserved" | "swapping" | "funding" | "purchasing" | "fulfilling" | "completed" | "delivered" | "failed" | "reversed" | "expired" | "held" | "cancelled";
+/** Statuses an order can never leave. */
+type TerminalStatus = "delivered" | "failed" | "reversed" | "expired" | "cancelled";
+/** The terminal status set — an order in one of these will not change again. */
+declare const TERMINAL_STATUSES: ReadonlySet<OrderStatus>;
+/** True when an order has reached a final state. */
+declare function isTerminal(status: OrderStatus): status is TerminalStatus;
+/** A reason a recipient cannot receive the item. */
+type RecipientCheckReason = "already_subscribed" | "not_found" | "ineligible";
+/** A reason an order failed. */
+type FailureReason = "underpaid" | "overpaid" | "no_memo" | "wrong_memo" | "undeliverable" | "expired" | (string & {});
+/** One supported payment currency, from `GET /v1/currencies`. */
+interface CurrencyInfo {
+    code: Currency;
+    chain: string;
+    name: string;
+}
+/** One product from the catalog, from `GET /v1/products`. */
+interface Product {
+    type: OrderType;
+    name: string;
+    parameter: Parameter;
+    min: number;
+    max: number;
+    /** A fixed allowed set (e.g. premium months `[3,6,12]`), or `null` for a continuous range. */
+    values: number[] | null;
+}
+/**
+ * The USDT processing-fee itemization (present only for `usdt_ton`).
+ *
+ * Invariant: `subtotal + processing_fee === total === amount`. This is an
+ * itemization of the fee already inside `amount` — never an additional charge.
+ * All fields are decimal USDT strings.
+ */
+interface FeeBreakdown {
+    subtotal: string;
+    processing_fee: string;
+    total: string;
+    description: string;
+    currency: "usdt";
+}
+/** A price quote from `GET /v1/pricing`. */
+interface PricingQuote {
+    type: OrderType;
+    quantity: number | null;
+    months: number | null;
+    /** All-in total to pay, in `currency`, as a decimal string. */
+    amount: string;
+    currency: Currency;
+    /** Itemized fee for `usdt_ton`; `null` for `ton`. */
+    fee: FeeBreakdown | null;
+    /** Informational market rate; `null` if the cache is cold. */
+    usdt_per_ton: string | null;
+    quoted_at: string;
+    /** A re-quote hint (`quoted_at + ttl`) — NOT a price lock. Price is fixed at order creation. */
+    valid_until: string;
+}
+/** The result of `POST /v1/recipients/check`. */
+interface RecipientCheck {
+    resolved: boolean;
+    eligible: boolean;
+    recipient_name: string | null;
+    reason: RecipientCheckReason | null;
+    /** Verbatim Telegram/Fragment rejection text; `null` when eligible. */
+    telegram_message: string | null;
+}
+/** The on-chain payment instruction attached to a created order. */
+interface PaymentInstruction {
+    currency: Currency;
+    chain: "ton";
+    /** The treasury OWNER address — the same for both `ton` and `usdt_ton`. */
+    pay_to_address: string | null;
+    /** The bare order UUID, attached as the on-chain text comment (no `STARS:` prefix). */
+    memo: string | null;
+    /** The exact amount to send, as a decimal string. */
+    amount: string;
+    amount_units: "ton" | "usdt";
+    /** Itemized fee for `usdt_ton`; `null` for `ton`. */
+    fee: FeeBreakdown | null;
+}
+/** The full order resource, from `GET /v1/orders` and `GET /v1/orders/:id`. */
+interface Order {
+    order_id: string;
+    status: OrderStatus;
+    type: OrderType;
+    recipient_username: string | null;
+    quantity: number | null;
+    months: number | null;
+    amount_ton: string | null;
+    payment_tx: string | null;
+    purchase_tx: string | null;
+    failure_reason: FailureReason | null;
+    reversal_tx: string | null;
+    telegram_message: string | null;
+    created_at: string;
+    updated_at: string;
+    /** Non-null only while `status === "awaiting_payment"`. */
+    expires_at: string | null;
+}
+/** The result of `POST /v1/orders` (201 new, or 200 idempotent replay). */
+interface CreateOrderResult {
+    order_id: string;
+    /**
+     * A fresh 201 create is always `awaiting_payment`. A 200 idempotent replay
+     * (same `Idempotency-Key`, same body) echoes the order's CURRENT status, which
+     * may already have advanced (e.g. `paid`, `delivered`) — so narrow against the
+     * full status domain, not the literal.
+     */
+    status: OrderStatus;
+    type: OrderType;
+    quantity: number | null;
+    months: number | null;
+    payment: PaymentInstruction;
+    expires_at: string;
+    /** `true` when the server returned 200 (idempotent replay) rather than 201 (fresh create). */
+    replayed: boolean;
+}
+/** One page of orders from `GET /v1/orders`. */
+interface OrdersPage {
+    orders: Order[];
+    /** Opaque keyset cursor for the next page, or `null` on the final page. */
+    next_cursor: string | null;
+}
+/** The terminal statuses that fire a webhook (NOT `cancelled`, which is a manual API action). */
+type WebhookStatus = "delivered" | "failed" | "reversed" | "expired";
+/**
+ * The terminal statuses that fire an order webhook — `delivered`/`failed`/
+ * `reversed`/`expired` (NOT `cancelled`, which is a manual API action and never
+ * webhooked). Mirrors `webhook_terminal` in the contract status-machine fixture.
+ */
+declare const WEBHOOK_TERMINAL: ReadonlySet<WebhookStatus>;
+/** The status an order is in immediately after a fresh `POST /v1/orders` (201). */
+declare const INITIAL_ORDER_STATUS: OrderStatus;
+/** Statuses an order can be cancelled from via `POST /v1/orders/:id/cancel`. */
+declare const CANCELLABLE_STATUSES: ReadonlySet<OrderStatus>;
+/**
+ * The body of an order webhook (POSTed to your `callback_url`). Deliberately
+ * minimal — fetch `GET /v1/orders/:id` for full detail. Treat every field beyond
+ * `order_id`/`status` as optional.
+ */
+interface WebhookEvent {
+    order_id: string;
+    status: WebhookStatus;
+    failure_reason?: FailureReason;
+    purchase_tx?: string;
+}
+
+/**
+ * Typed error taxonomy for the MyStars FaaS SDK.
+ *
+ * The server returns an envelope `{ error: { code, message, telegram_message? } }`
+ * for handled errors, and a bare `{ "error": "not_found" }` string for unmatched
+ * routes. `errorFromResponse` maps both forms — plus network/timeout failures —
+ * to the right class, keyed on the envelope `code` (the code, not the HTTP
+ * status, is authoritative; an unknown future code falls back to the base class
+ * so the SDK never crashes on a new code).
+ */
+
+/** Base class for every error this SDK throws. */
+declare abstract class MyStarsError extends Error {
+    constructor(message: string);
+}
+interface ApiErrorInit {
+    code: string;
+    status: number;
+    message: string;
+    telegramMessage?: string | undefined;
+    requestId?: string | undefined;
+    retryable?: boolean;
+    raw?: unknown;
+    /** The `Idempotency-Key` that was sent with the failed request (set by `createOrder`). */
+    idempotencyKey?: string | undefined;
+}
+/** Any error originating from an HTTP response (or a failed attempt to make one). */
+declare class MyStarsApiError extends MyStarsError {
+    /** The envelope `error.code`, or `"unknown"` / `"network"`. */
+    readonly code: string;
+    /** HTTP status code (`0` for a network/timeout failure). */
+    readonly status: number;
+    /** Buyer-facing Telegram/Fragment message, when the server supplied one. */
+    readonly telegramMessage?: string;
+    /** The `x-request-id` response header, when present. */
+    readonly requestId?: string;
+    /** Coarse hint that the failure is potentially transient. The retry policy decides for real. */
+    readonly retryable: boolean;
+    /** The parsed response body (or the thrown error), for debugging. */
+    readonly raw?: unknown;
+    /**
+     * The `Idempotency-Key` that was sent with the request that failed, when known.
+     *
+     * `createOrder` stamps this on a thrown error so you can SAFELY retry the
+     * create with the SAME key (`{ idempotencyKey: err.idempotencyKey }`) instead
+     * of minting a duplicate deliverable when you can't tell whether the order was
+     * created server-side. `undefined` for errors not raised by a keyed request.
+     */
+    readonly idempotencyKey?: string;
+    constructor(init: ApiErrorInit);
+}
+/** 400 — malformed request, validation failure, or missing `Idempotency-Key`. */
+declare class BadRequestError extends MyStarsApiError {
+}
+/** 401 — missing or invalid `X-Api-Key`. */
+declare class UnauthorizedError extends MyStarsApiError {
+}
+/** 403 — the API key is valid but the tenant is suspended or banned. */
+declare class ForbiddenError extends MyStarsApiError {
+}
+/** 404 — order not found (or an unmatched route). */
+declare class NotFoundError extends MyStarsApiError {
+}
+/** 409 — a generic conflict. */
+declare class ConflictError extends MyStarsApiError {
+}
+/** 409 — the same `Idempotency-Key` was reused with a different request body. */
+declare class IdempotencyConflictError extends ConflictError {
+}
+/** 409 — the order is not in `awaiting_payment` and cannot be cancelled. */
+declare class OrderNotCancellableError extends ConflictError {
+}
+/**
+ * 422 — the recipient cannot receive the item; no order was created.
+ *
+ * The server's 422 body carries only `telegram_message` (the buyer-facing reason
+ * to show your user) — NOT a structured `reason` code. For the structured
+ * `reason` (`already_subscribed` | `not_found` | `ineligible`), call
+ * `client.checkRecipient(...)` first and read its `reason` field.
+ */
+declare class RecipientIneligibleError extends MyStarsApiError {
+    readonly telegramMessage: string;
+    constructor(init: ApiErrorInit);
+}
+/** Which limiter a {@link RateLimitError} came from: the per-minute limiter or the daily order-cap/flood guard. */
+type RateLimitKind = "general" | "order_cap";
+/** 429 — rate limited. `kind` distinguishes the per-minute limiter from the daily order cap / flood guard. */
+declare class RateLimitError extends MyStarsApiError {
+    /** Milliseconds to wait before retrying, from `Retry-After`; `null` for the order-cap/flood limiter. */
+    readonly retryAfterMs: number | null;
+    readonly limit: number | null;
+    readonly remaining: number | null;
+    readonly reset: number | null;
+    /** `"general"` when RFC-9110 `RateLimit-*` headers are present; `"order_cap"` otherwise. */
+    readonly kind: RateLimitKind;
+    constructor(init: ApiErrorInit & {
+        retryAfterMs?: number | null;
+        limit?: number | null;
+        remaining?: number | null;
+        reset?: number | null;
+        kind: RateLimitKind;
+    });
+}
+/** 503 — a price source or upstream dependency is temporarily unavailable. Retryable. */
+declare class ServiceUnavailableError extends MyStarsApiError {
+}
+/** 500 — an unhandled server error. */
+declare class InternalServerError extends MyStarsApiError {
+}
+/** The request never produced an HTTP response (DNS, connection reset, aborted, etc.). */
+declare class NetworkError extends MyStarsApiError {
+}
+/** The request exceeded the configured timeout. */
+declare class TimeoutError extends NetworkError {
+}
+/** A webhook payload failed signature verification (or the header was missing/malformed). */
+declare class WebhookSignatureError extends MyStarsError {
+}
+/** `waitForOrder` gave up before the order reached a terminal state. */
+declare class OrderWaitTimeoutError extends MyStarsError {
+    /** The most recent order snapshot observed before timing out. */
+    readonly lastOrder: Order;
+    constructor(lastOrder: Order, message?: string);
+}
+/** Parse a `Retry-After` header (delta-seconds, or an HTTP-date) into milliseconds. */
+declare function parseRetryAfterMs(value: string | undefined, now?: number): number | null;
+/** Map an HTTP response (status + parsed body + headers) to the appropriate typed error. */
+declare function errorFromResponse(status: number, body: unknown, headers: Headers): MyStarsApiError;
+
+/**
+ * Retry policy + backoff for transient failures.
+ *
+ * Only retries when the request is idempotency-safe AND the failure is
+ * transient. Crucially, a `createOrder` retry reuses the SAME `Idempotency-Key`
+ * (the transport guarantees this), so a retried create returns the server's
+ * idempotent replay instead of minting a duplicate deliverable.
+ */
+
+/** The decision context handed to {@link RetryPolicy.retryOn} / {@link defaultShouldRetry} for one failed attempt. */
+interface RetryContext {
+    method: string;
+    path: string;
+    /** 0-based index of the attempt that just failed. */
+    attempt: number;
+    /** Whether this request is safe to replay (GET, or any request carrying an Idempotency-Key). */
+    idempotent: boolean;
+    /** The classified error from the failed attempt. */
+    error: MyStarsApiError;
+}
+/**
+ * Tunable retry policy passed to `MyStarsClient` (`retry`). Pass `false` instead
+ * to disable retries; omit a field to keep its default.
+ */
+interface RetryPolicy {
+    /** Max retries AFTER the first attempt. Default 3. */
+    maxRetries?: number;
+    /** Base backoff delay in ms. Default 500. */
+    baseDelayMs?: number;
+    /** Backoff cap in ms. Default 30_000. */
+    maxDelayMs?: number;
+    /** Jitter strategy. Default "full". */
+    jitter?: "full" | "none";
+    /** Honor a 429 `Retry-After` header as a lower bound on the delay. Default true. */
+    respectRetryAfter?: boolean;
+    /** Override the default retry classifier entirely. */
+    retryOn?: (ctx: RetryContext) => boolean;
+}
+/**
+ * The built-in classifier: retry idempotent requests on network/timeout/503/500,
+ * the general 429, and any other error flagged transient (e.g. a 502/504 gateway
+ * error, which `errorFromResponse` maps to a base error with `retryable: true`).
+ */
+declare function defaultShouldRetry(ctx: RetryContext): boolean;
+
+/**
+ * The HTTP transport: URL building, auth/idempotency headers, timeout, a bounded
+ * response read, JSON parsing, and the retry loop.
+ *
+ * Conventions: trailing-slash strip, AbortController timeout, bounded read,
+ * `X-Api-Key` + `Idempotency-Key` headers, and the key is NEVER placed into any
+ * logged/intercepted object.
+ */
+
+/** Info passed to {@link Interceptors.onRequest} before an attempt is sent. Never contains the API key. */
+interface RequestLogInfo {
+    method: string;
+    url: string;
+    idempotencyKey?: string;
+}
+/** Info passed to {@link Interceptors.onResponse} after a response is received. */
+interface ResponseLogInfo {
+    method: string;
+    url: string;
+    status: number;
+    /** Wall-clock duration of the attempt, in ms. */
+    durationMs: number;
+    requestId?: string;
+}
+/** Info passed to {@link Interceptors.onRetry} just before the SDK sleeps and retries. */
+interface RetryLogInfo {
+    method: string;
+    url: string;
+    /** 1-based index of the retry about to be made. */
+    attempt: number;
+    /** Backoff the SDK will wait before the retry, in ms. */
+    delayMs: number;
+    /** Why the retry fired, e.g. `"timeout (HTTP 0)"`. */
+    reason: string;
+}
+/**
+ * Observability hooks invoked around each request. All are optional, may be async
+ * (awaited inline), and NEVER receive the API key. Use them for logging/metrics —
+ * not for mutating the request.
+ */
+interface Interceptors {
+    onRequest?: (info: RequestLogInfo) => void | Promise<void>;
+    onResponse?: (info: ResponseLogInfo) => void | Promise<void>;
+    onRetry?: (info: RetryLogInfo) => void | Promise<void>;
+}
+
+/**
+ * Keyset (cursor) pagination over `GET /v1/orders`.
+ *
+ * `for await (const order of pager)` flattens every page; `pager.pages()` yields
+ * a page at a time; `pager.page(cursor?)` fetches a single page. The cursor is
+ * an opaque base64url token — never construct it by hand.
+ */
+
+/** Fetches one page given the previous page's `next_cursor` (`undefined` for the first page). */
+type FetchOrdersPage = (cursor: string | undefined) => Promise<OrdersPage>;
+/**
+ * Lazy, auto-advancing view over `GET /v1/orders`. Iterate it directly to stream
+ * every order, or use `pages()` / `page()` for page-at-a-time control. Returned by
+ * `client.listOrders(...)` — you rarely construct it yourself.
+ *
+ * @example
+ * ```ts
+ * for await (const order of client.listOrders({ status: "delivered" })) {
+ *   console.log(order.order_id);
+ * }
+ * // or collect everything: const all = await client.listOrders().all();
+ * ```
+ */
+declare class OrdersPager implements AsyncIterable<Order> {
+    private readonly fetchPage;
+    private readonly startCursor;
+    /**
+     * @param fetchPage - fetches a page given a cursor (the client wires this to the transport)
+     * @param startCursor - an optional cursor to begin from (resumes mid-stream)
+     */
+    constructor(fetchPage: FetchOrdersPage, startCursor?: string);
+    /** Fetch a single page. Pass the previous page's `next_cursor` to advance. */
+    page(cursor?: string): Promise<OrdersPage>;
+    /** Yield one page at a time until `next_cursor` is null. */
+    pages(): AsyncIterableIterator<OrdersPage>;
+    /** Yield every order across all pages. */
+    [Symbol.asyncIterator](): AsyncIterator<Order>;
+    /** Collect every order across all pages into a single array. */
+    all(): Promise<Order[]>;
+}
+
+/**
+ * Reconciliation — catch terminal transitions a dropped or dead-lettered webhook
+ * missed. Webhook delivery is at-least-once and unordered, so a safety net that
+ * diffs the server's order list against your local store closes the gap.
+ *
+ * Walks `GET /v1/orders` newest-first; for each TERMINAL order your store hasn't
+ * recorded (`isKnown` returns false), it's collected (and `onMissed` fired).
+ * Stops paginating once it passes `since` (orders are newest-first).
+ */
+
+/** The slice of the client {@link reconcile} needs (structurally typed to avoid a cycle). */
+interface ReconcileClient {
+    listOrders(params?: {
+        status?: OrderStatus;
+        limit?: number;
+    }): OrdersPager;
+}
+/** Options for {@link reconcile} — your store check plus optional status/since/page-size filters. */
+interface ReconcileOptions {
+    /** Only reconcile a specific terminal status (else all terminal orders). */
+    status?: OrderStatus;
+    /** Stop once orders are older than this (orders are newest-first). */
+    since?: Date | string;
+    /** Page size for the underlying list. */
+    limit?: number;
+    /** Your store's check: has this terminal order already been processed? */
+    isKnown: (order: Order) => boolean | Promise<boolean>;
+    /** Fired for each missed terminal order, in newest-first order. */
+    onMissed?: (order: Order) => void | Promise<void>;
+}
+/**
+ * Walk the server's orders newest-first and collect TERMINAL orders your store
+ * hasn't recorded — the safety net for webhooks that were dropped or dead-lettered.
+ *
+ * @param client - anything with a `listOrders` returning an {@link OrdersPager} (a `MyStarsClient` fits)
+ * @param opts - the {@link ReconcileOptions}; `isKnown` is required, `since` bounds the scan
+ * @returns the missed terminal orders, newest-first (also delivered one-by-one to `onMissed`)
+ * @throws `MyStarsApiError` if a page fetch fails
+ * @example
+ * ```ts
+ * const missed = await client.reconcile({
+ *   since: new Date(Date.now() - 24 * 3600_000),
+ *   isKnown: (o) => myStore.has(o.order_id),
+ *   onMissed: (o) => myStore.markTerminal(o),
+ * });
+ * ```
+ */
+declare function reconcile(client: ReconcileClient, opts: ReconcileOptions): Promise<Order[]>;
+
+/**
+ * Poll an order until it reaches a terminal state (or a custom predicate / the
+ * deadline). Polling a still-`awaiting_payment` order also nudges the server's
+ * on-demand payment detection, so this doubles as a payment tracker.
+ */
+
+/** Polling/backoff knobs and observation hooks for {@link waitForOrder} / `client.waitForOrder`. */
+interface WaitForOrderOptions {
+    /** First poll interval (ms). Default 2000. */
+    pollIntervalMs?: number;
+    /** Upper bound on the backed-off poll interval (ms). Default 15_000. */
+    maxPollIntervalMs?: number;
+    /** Multiplier applied to the interval after each poll. Default 1.5. */
+    backoffFactor?: number;
+    /** Total time to wait before throwing `OrderWaitTimeoutError` (ms). Default 30 min. */
+    maxWaitMs?: number;
+    /** Apply jitter to the poll interval. Default "full". */
+    jitter?: "full" | "none";
+    /** Resolve when this returns true. Default: the order is terminal. */
+    until?: (order: Order) => boolean;
+    /** Called whenever the observed status changes (including the first observation). */
+    onUpdate?: (order: Order) => void;
+    signal?: AbortSignal;
+}
+
+/**
+ * `MyStarsClient` — the typed entry point to the MyStars FaaS API.
+ *
+ * Wraps the 8 public `/v1` endpoints with typed requests/responses, automatic
+ * retries (honoring `Retry-After`), automatic `Idempotency-Key` generation +
+ * safe reuse on retry, keyset pagination, and order tracking.
+ */
+
+/** Base URL of the production B2B edge (`api.mystars.tg`). */
+declare const PRODUCTION_BASE_URL = "https://api.mystars.tg/v1";
+/** Configuration for {@link MyStarsClient}. Only `apiKey` is required. */
+interface MyStarsClientOptions {
+    /** Your tenant API key (`faas_…`). Sent as the `X-Api-Key` header. */
+    apiKey: string;
+    /** Full base URL incl. `/v1`. Defaults to production (`api.mystars.tg`). */
+    baseUrl?: string;
+    /** Injected fetch. Defaults to the global `fetch`. */
+    fetch?: typeof fetch;
+    /** Per-request timeout in ms. Default 30_000. */
+    timeoutMs?: number;
+    /** Retry policy, or `false` to disable retries. */
+    retry?: RetryPolicy | false;
+    /** Generates the `Idempotency-Key` for `createOrder` when the caller omits one. Default uuid v4. */
+    idempotencyKeyFactory?: () => string;
+    /** Sent as `User-Agent` (Node only; browsers ignore it). */
+    userAgent?: string;
+    /** Observability hooks. Never receive the API key. */
+    interceptors?: Interceptors;
+    /** Test injectables. */
+    now?: () => number;
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+    random?: () => number;
+}
+/** Per-call options common to every request — currently just an `AbortSignal`. */
+interface RequestOptions {
+    signal?: AbortSignal;
+}
+/** Options for {@link MyStarsClient.createOrder} — a {@link RequestOptions} plus an optional stable key. */
+interface CreateOrderOptions extends RequestOptions {
+    /** Reuse a specific idempotency key (e.g. derived from your own order id). */
+    idempotencyKey?: string;
+}
+/** Discriminated input for {@link MyStarsClient.getPricing} — sized by `quantity` (stars) or `months` (premium). */
+type PricingParams = {
+    type: "stars";
+    quantity: number;
+    payment_currency?: Currency;
+} | {
+    type: "premium";
+    months: number;
+    payment_currency?: Currency;
+};
+/** Discriminated input for {@link MyStarsClient.checkRecipient} (premium may include the intended `months`). */
+type CheckRecipientParams = {
+    type: "stars";
+    recipient: {
+        username: string;
+    };
+} | {
+    type: "premium";
+    recipient: {
+        username: string;
+    };
+    months?: number;
+};
+/** Discriminated input for {@link MyStarsClient.createOrder} — recipient + sizing + optional currency/callback. */
+type CreateOrderParams = {
+    type: "stars";
+    recipient: {
+        username: string;
+    };
+    quantity: number;
+    payment_currency?: Currency;
+    callback_url?: string;
+} | {
+    type: "premium";
+    recipient: {
+        username: string;
+    };
+    months: number;
+    payment_currency?: Currency;
+    callback_url?: string;
+};
+/** Filters for {@link MyStarsClient.listOrders} — status, page size, and a starting cursor. */
+interface ListOrdersParams {
+    status?: OrderStatus;
+    /** 1-100; the server caps at 100 and defaults to 50. */
+    limit?: number;
+    cursor?: string;
+}
+/** The typed entry point to the MyStars FaaS `/v1` API. See the module overview for the full flow. */
+declare class MyStarsClient {
+    private readonly transport;
+    private readonly idempotencyKeyFactory;
+    private readonly now;
+    private readonly sleep;
+    private readonly random;
+    /**
+     * @param opts - the {@link MyStarsClientOptions} (at minimum `apiKey`). Prefer the
+     *   {@link MyStarsClient.production} factory.
+     * @throws `Error` if `apiKey` is missing, or no `fetch` is available (Node <18 — pass `fetch` explicitly)
+     */
+    constructor(opts: MyStarsClientOptions);
+    /**
+     * Build a client pointed at production (`api.mystars.tg`).
+     *
+     * @param apiKey - your tenant `faas_…` API key
+     * @param opts - any other {@link MyStarsClientOptions} except `apiKey`/`baseUrl`
+     * @returns a configured client
+     * @example
+     * ```ts
+     * const client = MyStarsClient.production(process.env.MYSTARS_API_KEY!);
+     * ```
+     */
+    static production(apiKey: string, opts?: Omit<MyStarsClientOptions, "apiKey" | "baseUrl">): MyStarsClient;
+    /**
+     * `GET /v1/currencies` — the supported on-chain payment currencies.
+     *
+     * @param opts - optional `signal` to abort the request
+     * @returns the supported {@link CurrencyInfo} list
+     * @throws `MyStarsApiError` on an API/network failure
+     */
+    listCurrencies(opts?: RequestOptions): Promise<CurrencyInfo[]>;
+    /**
+     * `GET /v1/products` — the orderable product catalog (price-free).
+     *
+     * @param opts - optional `signal` to abort the request
+     * @returns the {@link Product} catalog (buyable shapes + limits)
+     * @throws `MyStarsApiError` on an API/network failure
+     */
+    listProducts(opts?: RequestOptions): Promise<Product[]>;
+    /**
+     * `GET /v1/pricing` — quote the all-in price for an item. Probe-rate-limited (30/min).
+     *
+     * @param params - `{ type, quantity | months, payment_currency? }`; `payment_currency` defaults server-side
+     * @param opts - optional `signal` to abort the request
+     * @returns the {@link PricingQuote} — `amount` is the all-in total in `currency`; `fee` is itemized for `usdt_ton`
+     * @throws `MyStarsValidationError` if `quantity`/`months` is out of range
+     * @throws `RateLimitError` (429) if the probe limit is exceeded
+     * @throws `ServiceUnavailableError` (503) if a price source is temporarily down
+     * @example
+     * ```ts
+     * const q = await client.getPricing({ type: "stars", quantity: 500, payment_currency: "ton" });
+     * console.log(`pay ${q.amount} ${q.currency}`);
+     * ```
+     */
+    getPricing(params: PricingParams, opts?: RequestOptions): Promise<PricingQuote>;
+    /**
+     * `POST /v1/recipients/check` — resolve a `@username` and check eligibility before ordering.
+     *
+     * @param params - `{ type, recipient: { username }, months? }`; the username is canonicalized (strip `@`, lowercase)
+     * @param opts - optional `signal` to abort the request
+     * @returns the {@link RecipientCheck} — `resolved`/`eligible`, the display `recipient_name`, and a `reason` when ineligible
+     * @throws `MyStarsValidationError` if the username is malformed
+     * @throws `MyStarsApiError` on an API/network failure
+     */
+    checkRecipient(params: CheckRecipientParams, opts?: RequestOptions): Promise<RecipientCheck>;
+    /**
+     * `POST /v1/orders` — create an order. An `Idempotency-Key` is sent once and
+     * reused across this call's retries, so a retried create returns the idempotent
+     * replay (`replayed: true`) instead of a duplicate.
+     *
+     * MONEY SAFETY — supply a STABLE key derived from YOUR OWN order id
+     * (`{ idempotencyKey: \`order-\${myOrderId}\` }`). The auto-generated uuid only
+     * dedupes WITHIN a single `createOrder` call's internal retries; a brand-new
+     * call (e.g. your process crashed and re-ran) mints a fresh uuid and can create
+     * a SECOND order for the same intent. A caller-stable key makes the create
+     * idempotent across process restarts and at-least-once job runners.
+     *
+     * On failure the thrown {@link MyStarsApiError} carries the `idempotencyKey`
+     * that was used — when you can't tell whether the order was created
+     * server-side, retry with that exact key (`{ idempotencyKey: err.idempotencyKey }`)
+     * to get the idempotent replay rather than a duplicate.
+     *
+     * @param params - `{ type, recipient: { username }, quantity | months, payment_currency?, callback_url? }`
+     * @param opts - optional caller-stable `idempotencyKey` (recommended) and `signal`
+     * @returns the {@link CreateOrderResult} — `payment` instruction + `expires_at`; `replayed` is `true` on a 200 idempotent replay
+     * @throws `MyStarsValidationError` if inputs are invalid
+     * @throws `RecipientIneligibleError` (422) if the recipient cannot receive the item (no order created)
+     * @throws `IdempotencyConflictError` (409) if the same key is reused with a different body
+     * @throws `MyStarsApiError` on any other API failure (carries the `idempotencyKey` for safe retry)
+     * @example
+     * ```ts
+     * const order = await client.createOrder(
+     *   { type: "stars", recipient: { username: "durov" }, quantity: 100 },
+     *   { idempotencyKey: `order-${myOrderId}` },
+     * );
+     * // pay order.payment.amount → order.payment.pay_to_address, comment = order.payment.memo
+     * ```
+     */
+    createOrder(params: CreateOrderParams, opts?: CreateOrderOptions): Promise<CreateOrderResult>;
+    /**
+     * `GET /v1/orders/:id` — fetch one order (tenant-scoped). Polling an
+     * `awaiting_payment` order also nudges the server's on-demand payment detection.
+     *
+     * @param orderId - the order UUID
+     * @param opts - optional `signal` to abort the request
+     * @returns the {@link Order}
+     * @throws `NotFoundError` (404) if no such order exists for this tenant
+     * @throws `MyStarsApiError` on any other API failure
+     */
+    getOrder(orderId: string, opts?: RequestOptions): Promise<Order>;
+    /**
+     * `POST /v1/orders/:id/cancel` — cancel an `awaiting_payment` order.
+     *
+     * @param orderId - the order UUID
+     * @param opts - optional `signal` to abort the request
+     * @returns `{ order_id, status: "cancelled" }`
+     * @throws `OrderNotCancellableError` (409) if the order is no longer `awaiting_payment` (a retry after a lost success can also surface this even though the cancel committed — re-check with `getOrder`)
+     * @throws `MyStarsApiError` on any other API failure
+     */
+    cancelOrder(orderId: string, opts?: RequestOptions): Promise<{
+        order_id: string;
+        status: "cancelled";
+    }>;
+    private listOrdersPage;
+    /**
+     * `GET /v1/orders` — an auto-paginating view: `for await (const order of client.listOrders())`.
+     * The pager owns the cursor; `params.cursor` (if given) is the starting page.
+     *
+     * @param params - optional `status` filter, `limit` (1-100), and a starting `cursor`
+     * @param opts - optional `signal` to abort the underlying page fetches
+     * @returns an {@link OrdersPager} (async-iterable; `.pages()` / `.page()` / `.all()`)
+     * @example
+     * ```ts
+     * for await (const order of client.listOrders({ status: "delivered" })) {
+     *   console.log(order.order_id);
+     * }
+     * ```
+     */
+    listOrders(params?: ListOrdersParams, opts?: RequestOptions): OrdersPager;
+    /**
+     * Poll `GET /v1/orders/:id` until the order is terminal (or the deadline).
+     *
+     * @param orderId - the order UUID
+     * @param options - the {@link WaitForOrderOptions} (intervals, deadline, `until`, `onUpdate`, `signal`)
+     * @returns the final {@link Order} once terminal
+     * @throws `OrderWaitTimeoutError` if `maxWaitMs` elapses first (carries the last snapshot)
+     * @throws `MyStarsApiError` if a poll fails non-transiently
+     * @example
+     * ```ts
+     * const final = await client.waitForOrder(order.order_id, { onUpdate: (o) => console.log(o.status) });
+     * ```
+     */
+    waitForOrder(orderId: string, options?: WaitForOrderOptions): Promise<Order>;
+    /**
+     * Diff the server's orders against your local store to catch webhook-missed terminal transitions.
+     *
+     * @param options - the {@link ReconcileOptions}; `isKnown` is required, `since` bounds the scan
+     * @returns the missed terminal {@link Order}s, newest-first
+     * @throws `MyStarsApiError` if a page fetch fails
+     */
+    reconcile(options: ReconcileOptions): Promise<Order[]>;
+}
+
+/**
+ * Webhook signature verification.
+ *
+ * Reimplements the server's webhook signing byte-for-byte: the `X-Faas-Signature`
+ * header is the lowercase-hex HMAC-SHA256 of the RAW request body under the tenant's
+ * webhook secret — no timestamp. During a 24h secret rotation the header is two
+ * comma-joined signatures (`"<current>,<previous>"`); we split on `,` and
+ * constant-time-compare each, so verification holds with EITHER secret.
+ *
+ * Universal: prefers Web Crypto (`globalThis.crypto.subtle`) so it runs in Deno,
+ * Bun, Cloudflare Workers, and browsers; on default Node 18 (where the global is
+ * absent) it falls back to `node:crypto`'s `webcrypto`. The verifier is therefore async.
+ */
+
+/**
+ * Verify an `X-Faas-Signature` header against the raw webhook body.
+ * Handles the single-signature and the `"current,previous"` rotation forms.
+ */
+declare function verifyWebhookSignature(rawBody: string | Uint8Array, signatureHeader: string | null | undefined, secret: string): Promise<boolean>;
+/**
+ * Verify the signature, then JSON-parse the body into a typed {@link WebhookEvent}.
+ * Throws {@link WebhookSignatureError} on a bad/missing signature or unparseable body.
+ *
+ * IMPORTANT: pass the RAW request bytes/string (verify before any framework
+ * re-serializes the JSON), and dedup on `event.order_id` — delivery is
+ * at-least-once and unordered.
+ */
+declare function constructEvent(rawBody: string | Uint8Array, signatureHeader: string | null | undefined, secret: string): Promise<WebhookEvent>;
+
+/**
+ * Drop-in webhook handlers for Express and Fastify.
+ *
+ * Both verify the `X-Faas-Signature` over the RAW body, parse the event, hand it
+ * to your `onEvent`, and reply `2xx` fast (the server needs a 2xx within 5s).
+ * They are structurally typed (no `express`/`fastify` runtime dependency), so the
+ * SDK stays dependency-free.
+ *
+ * Dedup is YOUR job — delivery is at-least-once and unordered; key on
+ * `event.order_id` (+ `status`).
+ */
+
+interface ExpressLikeReq {
+    headers: Record<string, string | string[] | undefined>;
+    body?: unknown;
+    rawBody?: unknown;
+}
+interface ExpressLikeRes {
+    status(code: number): ExpressLikeRes;
+    send(body?: unknown): unknown;
+}
+type ExpressLikeHandler = (req: ExpressLikeReq, res: ExpressLikeRes) => Promise<void>;
+/** Options for {@link expressWebhook} / {@link fastifyWebhook} — the secret, the event handler, and an error hook. */
+interface WebhookMiddlewareOptions<Req = unknown> {
+    /** The tenant webhook secret, or a function resolving it per-request (e.g. multi-tenant routing). */
+    secret: string | ((req: Req) => string | Promise<string>);
+    /** Called with the verified, parsed event. Keep it fast; offload heavy work to a queue. */
+    onEvent: (event: WebhookEvent, ctx: {
+        rawBody: string;
+        req: Req;
+    }) => void | Promise<void>;
+    /** Optional hook for signature/handler errors (after the response is sent). */
+    onError?: (err: unknown, req: Req) => void;
+}
+/**
+ * Express handler. REQUIRES the raw body — mount with `express.raw({ type: "*\/*" })`
+ * (or any raw-body parser) on the webhook route so `req.body`/`req.rawBody` is a
+ * Buffer/string, NOT a pre-parsed object.
+ */
+declare function expressWebhook(opts: WebhookMiddlewareOptions<ExpressLikeReq>): ExpressLikeHandler;
+interface FastifyLikeReq {
+    headers: Record<string, string | string[] | undefined>;
+    body?: unknown;
+    rawBody?: unknown;
+}
+interface FastifyLikeReply {
+    code(statusCode: number): FastifyLikeReply;
+    send(payload?: unknown): unknown;
+}
+type FastifyLikeHandler = (req: FastifyLikeReq, reply: FastifyLikeReply) => Promise<void>;
+/**
+ * Fastify handler. REQUIRES the raw body — register a content-type parser that
+ * keeps the Buffer (e.g. `addContentTypeParser("application/json", { parseAs: "buffer" }, (req, body, done) => done(null, body))`)
+ * so `req.body` is a Buffer/string, not a pre-parsed object.
+ */
+declare function fastifyWebhook(opts: WebhookMiddlewareOptions<FastifyLikeReq>): FastifyLikeHandler;
+
+/**
+ * Retail-markup calculator.
+ *
+ * Takes our WHOLESALE quote (what you pay us) and computes the price to charge
+ * your end-customer after adding your OWN retail margin — and, optionally,
+ * passing our processing fee straight through to the customer.
+ *
+ * Money is handled to the same grid the server uses: USDT to whole cents via the
+ * exact two-stage cent-ceil (`ceilUsdToCents`), and TON to the 0.0001-GRAM grid.
+ * The cross-language `markup-vectors.json` fixture pins this so the TS and Python
+ * SDKs produce identical retail prices.
+ *
+ * NOTE: our wholesale markup is set server-side and is redacted — this module
+ * never sees it. The margin here is purely YOUR retail margin on top of the
+ * quoted wholesale amount.
+ */
+
+/**
+ * Ceil a USD(T) amount to whole cents WITHOUT IEEE-754 drift — snap to integer
+ * micro-USDT first, then ceil to the cent grid. Byte-identical to the server's
+ * `ceilUsdToCents` (web checkout + FaaS `/v1/pricing` land on the same cent).
+ *
+ * @example ceilUsdToCents(0.06)   // 0.06  (naive Math.ceil(x*100)/100 returns 0.07)
+ * @example ceilUsdToCents(3.3461) // 3.35
+ */
+declare function ceilUsdToCents(usd: number): number;
+/** Ceil a TON amount to the 0.0001-GRAM grid (snap to integer nanoTON first). */
+declare function ceilTonTo4dp(ton: number): number;
+/** The wholesale quote a retail markup is applied to (a `PricingQuote` or a `PaymentInstruction` both fit). */
+interface MarkupInput {
+    amount: string;
+    currency: Currency;
+    fee: FeeBreakdown | null;
+}
+/** Your retail-margin configuration for {@link applyRetailMarkup}. */
+interface RetailMarkupConfig {
+    /** Your retail margin, in percent, applied to the goods value (e.g. 12.5 for +12.5%). */
+    marginPct: number;
+    /**
+     * When true (default), our processing fee (`usdt_ton` only) is added to the
+     * customer total as a separate line — the customer pays it, you remit it to us,
+     * and it doesn't eat your margin. When false, you absorb the fee out of your margin.
+     */
+    passThroughProcessingFee?: boolean;
+}
+/** One labelled line of a {@link RetailQuote} breakdown (label + decimal-string amount). */
+interface RetailLineItem {
+    label: string;
+    amount: string;
+}
+/** The customer-facing breakdown returned by {@link applyRetailMarkup}. All amounts are decimal strings. */
+interface RetailQuote {
+    currency: Currency;
+    /** What you pay us (the wholesale quote amount). */
+    wholesaleAmount: string;
+    marginPct: number;
+    /** The base goods value before your margin (the fee's `subtotal` for usdt_ton, else `amount`). */
+    goods: string;
+    /** Your added margin (subtotal − goods). */
+    markup: string;
+    /** Marked-up goods (goods + markup). */
+    subtotal: string;
+    /** Passed-through processing fee (usdt_ton + passThrough), else "0". */
+    processingFee: string;
+    /** What to charge your customer (subtotal + processingFee). */
+    total: string;
+    /** Your gross margin on the sale (total − wholesaleAmount). */
+    profit: string;
+    lineItems: RetailLineItem[];
+}
+/**
+ * Apply your retail margin to a wholesale quote and return an itemized
+ * customer-facing breakdown.
+ */
+declare function applyRetailMarkup(input: MarkupInput, config: RetailMarkupConfig): RetailQuote;
+
+/**
+ * Non-custodial invoice builder.
+ *
+ * Turns an order's `payment` block into things you can pay with: smallest-unit
+ * amounts, a `ton://transfer` deeplink, a Tonkeeper link, a QR payload, and TON
+ * Connect message(s). This module holds NO keys and signs nothing — feed the
+ * output to a wallet / TON Connect, or to `@mystars-tg/faas-wallet` to broadcast.
+ */
+
+/** Message value (nanoTON) attached to a USDT jetton transfer to cover its gas. */
+declare const JETTON_TRANSFER_GAS_NANO = "50000000";
+/**
+ * Convert a non-negative decimal string to integer smallest units (half-up),
+ * without IEEE-754 drift. A leading `-` is rejected — a payment amount is never
+ * negative, and a signed value would build a nonsensical (or zero) transfer.
+ */
+declare function decimalToUnits(amount: string, decimals: number): bigint;
+/** Decimal TON string → nanoTON. */
+declare function toNano(amount: string): bigint;
+/** Decimal USDT string → micro-USDT. */
+declare function toMicro(amount: string): bigint;
+/** One TON Connect `messages[]` entry — feed to `tonConnectUI.sendTransaction({ messages })`. */
+interface TonConnectMessage {
+    address: string;
+    /** nanoTON, as a string (TON Connect's expected form). */
+    amount: string;
+    /** base64 BoC payload. */
+    payload?: string;
+}
+/** Options for the invoice builders — only needed to produce a signable USDT (jetton) message. */
+interface BuildInvoiceOptions {
+    /** The payer's wallet address (raw or friendly) — required to build a USDT jetton message. */
+    senderAddress?: string;
+    /** The payer's OWN USDT jetton wallet address — required to build a USDT TON Connect message. */
+    jettonWalletAddress?: string;
+    /** Validity window for the TON Connect transaction, in seconds. Default 600. */
+    validForSeconds?: number;
+    /** Stamp for `valid_until` (epoch ms). Pass `Date.now()` — kept injectable for determinism. */
+    now?: number;
+}
+/** The aggregated payable artifacts for an order, returned by {@link buildPaymentRequest}. */
+interface PaymentRequest {
+    currency: PaymentInstruction["currency"];
+    payToAddress: string;
+    memo: string;
+    amountUnits: "ton" | "usdt";
+    /** nanoTON (ton) or micro-USDT (usdt_ton), as a string. */
+    amountSmallestUnit: string;
+    /** `ton://transfer/...` — TON only (a USDT jetton transfer has no plain deeplink). */
+    tonDeeplink?: string;
+    /** `https://app.tonkeeper.com/transfer/...` — TON only. */
+    tonkeeperLink?: string;
+    /** A URI to render as a QR code — TON only. */
+    qrPayload?: string;
+    /** TON Connect `messages` array (USDT requires `senderAddress` + `jettonWalletAddress`). */
+    tonConnect: TonConnectMessage[];
+    /** Set when a field couldn't be produced (e.g. USDT without a resolved jetton wallet). */
+    note?: string;
+}
+/**
+ * Build TON Connect message(s) for the payment. Throws for a USDT payment unless
+ * `senderAddress` + `jettonWalletAddress` are supplied (a jetton message must be
+ * sent to the payer's own jetton wallet).
+ */
+declare function buildTonConnectMessages(payment: PaymentInstruction, opts?: BuildInvoiceOptions): TonConnectMessage[];
+/** Build a `ton://transfer` deeplink. TON only — throws for USDT. */
+declare function buildTonDeeplink(payment: PaymentInstruction): string;
+/**
+ * Aggregate everything you can pay the order with. Best-effort: TON yields the
+ * full set; USDT yields the smallest-unit amount + TON Connect message only when
+ * `senderAddress` + `jettonWalletAddress` are supplied (otherwise `note` explains).
+ */
+declare function buildPaymentRequest(payment: PaymentInstruction, opts?: BuildInvoiceOptions): PaymentRequest;
+
+/** Build the op-0 text-comment payload for `comment`, as a base64 BoC. */
+declare function buildCommentPayload(comment: string): string;
+
+/** `forward_ton_amount` carried inside the transfer (0 — the memo still survives in internal_transfer). */
+declare const FORWARD_TON_AMOUNT_NANO: bigint;
+/** Jetton transfer opcode (TEP-74). */
+declare const JETTON_TRANSFER_OP = 260734629;
+/** Parse a TON address (friendly base64url or raw `wc:hex`) into workchain + 32-byte hash. Throws on a bad checksum/shape. */
+declare function parseTonAddress(address: string): {
+    workchain: number;
+    hash: Uint8Array;
+};
+/**
+ * Build the TEP-74 jetton transfer BoC payload (base64).
+ *
+ * @param amountMicro - jetton amount in micro-units (e.g. "4990000" for 4.99 USDT)
+ * @param destination - the recipient OWNER address (the FaaS `pay_to_address`), raw or friendly
+ * @param sender - the payer's wallet address (`response_destination`), raw or friendly
+ * @param memo - the bare order UUID (op-0 comment in the forward payload)
+ */
+declare function buildJettonTransferPayload(amountMicro: string | bigint, destination: string, sender: string, memo: string): string;
+
+/**
+ * Lightweight client-side validation that mirrors the server's documented
+ * constraints (and the `GET /v1/products` catalog), so common mistakes fail
+ * fast without a round trip. These constants track the pinned CONTRACT_VERSION.
+ */
+
+/** Minimum Stars quantity a single order can buy (inclusive). */
+declare const STARS_MIN_QUANTITY = 50;
+/** Maximum Stars quantity a single order can buy (inclusive). */
+declare const STARS_MAX_QUANTITY = 1000000;
+/** The allowed Telegram Premium subscription lengths, in months. */
+declare const PREMIUM_MONTHS: readonly number[];
+/** Thrown for invalid input caught before any HTTP request is made. */
+declare class MyStarsValidationError extends MyStarsError {
+}
+/** Canonicalize a Telegram username the same way the server does: strip a leading `@`, lowercase. */
+declare function canonicalUsername(input: string): string;
+
+/**
+ * The MyStars FaaS API contract version this SDK was built and verified against.
+ *
+ * Bumped in lockstep with the SDK's contract fixtures; CI fails the build on drift.
+ */
+declare const CONTRACT_VERSION = "1.9.0";
+/** This SDK's own semantic version (decoupled from the API contract version). */
+declare const SDK_VERSION = "0.1.2";
+
+export { BadRequestError, type BuildInvoiceOptions, CANCELLABLE_STATUSES, CONTRACT_VERSION, type CheckRecipientParams, ConflictError, type CreateOrderOptions, type CreateOrderParams, type CreateOrderResult, type Currency, type CurrencyInfo, FORWARD_TON_AMOUNT_NANO, type FailureReason, type FeeBreakdown, type FetchOrdersPage, ForbiddenError, INITIAL_ORDER_STATUS, IdempotencyConflictError, type Interceptors, InternalServerError, JETTON_TRANSFER_GAS_NANO, JETTON_TRANSFER_OP, type ListOrdersParams, type MarkupInput, MyStarsApiError, MyStarsClient, type MyStarsClientOptions, MyStarsError, MyStarsValidationError, NetworkError, NotFoundError, type Order, OrderNotCancellableError, type OrderStatus, type OrderType, OrderWaitTimeoutError, type OrdersPage, OrdersPager, PREMIUM_MONTHS, PRODUCTION_BASE_URL, type Parameter, type PaymentInstruction, type PaymentRequest, type PricingParams, type PricingQuote, type Product, RateLimitError, type RateLimitKind, type RecipientCheck, type RecipientCheckReason, RecipientIneligibleError, type ReconcileClient, type ReconcileOptions, type RequestLogInfo, type RequestOptions, type ResponseLogInfo, type RetailLineItem, type RetailMarkupConfig, type RetailQuote, type RetryContext, type RetryLogInfo, type RetryPolicy, SDK_VERSION, STARS_MAX_QUANTITY, STARS_MIN_QUANTITY, ServiceUnavailableError, TERMINAL_STATUSES, type TerminalStatus, TimeoutError, type TonConnectMessage, UnauthorizedError, WEBHOOK_TERMINAL, type WaitForOrderOptions, type WebhookEvent, type WebhookMiddlewareOptions, WebhookSignatureError, type WebhookStatus, applyRetailMarkup, buildCommentPayload, buildJettonTransferPayload, buildPaymentRequest, buildTonConnectMessages, buildTonDeeplink, canonicalUsername, ceilTonTo4dp, ceilUsdToCents, constructEvent, decimalToUnits, defaultShouldRetry, errorFromResponse, expressWebhook, fastifyWebhook, isTerminal, parseRetryAfterMs, parseTonAddress, reconcile, toMicro, toNano, verifyWebhookSignature };