@settlemint/dalp-sdk 3.1.18-main.33808370488 → 3.1.18

package/dist/scalars/exchange-rates.d.ts

@@ -1,27 +0,0 @@
-/**
- * Rich-scalar decoding for the exchange-rates list response.
- *
- * The wire carries a contract-faithful decimal string and a lowercase address.
- * This turns them into a `dnum` amount and a checksummed address. It reads the
- * shape structurally rather than through a schema library: the SDK ships no
- * runtime validator, because the platform validated the body on the way out and
- * a second copy of every schema would reach every consumer for no added
- * guarantee.
- *
- * @module
- */
-import { type BigDecimalValue } from "./big-decimal.ts";
-import { type EthereumAddressValue } from "./ethereum-address.ts";
-export interface ExchangeRateRow {
-    readonly rate: BigDecimalValue | null;
-    readonly feedAddress: EthereumAddressValue | null;
-    readonly [key: string]: unknown;
-}
-export interface ExchangeRatesListResponse {
-    readonly data: ReadonlyArray<ExchangeRateRow>;
-    readonly [key: string]: unknown;
-}
-/** Decode a list response, converting its scalar columns. */
-export declare function decodeExchangeRatesListResponse(payload: unknown): ExchangeRatesListResponse;
-/** Kept for callers that spread this as a response transformer. */
-export declare const exchangeRatesListTransformer: (data: unknown) => Promise<ExchangeRatesListResponse>;

package/dist/scalars/index.d.ts

@@ -1,18 +0,0 @@
-/**
- * Rich-scalar decoders.
- *
- * The route table names which fields carry a scalar, keyed by dotted path, so a
- * caller applies these where the declaration says a scalar lives rather than
- * guessing from a field name. They are plain functions: the SDK ships no
- * runtime schema library, because the platform validates on the way out.
- *
- * @module
- */
-export { decodeBigDecimal, encodeBigDecimal } from "./big-decimal.ts";
-export type { BigDecimalValue } from "./big-decimal.ts";
-export { decodeEthereumAddress, tryDecodeEthereumAddress } from "./ethereum-address.ts";
-export type { EthereumAddressValue } from "./ethereum-address.ts";
-export { decodeOrganizationId, tryDecodeOrganizationId } from "./organization-id.ts";
-export type { OrganizationIdValue } from "./organization-id.ts";
-export { decodeExchangeRatesListResponse, exchangeRatesListTransformer } from "./exchange-rates.ts";
-export type { ExchangeRateRow, ExchangeRatesListResponse } from "./exchange-rates.ts";

package/dist/scalars/index.js

@@ -1,86 +0,0 @@
-import {
-  DalpSdkError
-} from "../chunk-y0d2c7kp.js";
-
-// src/scalars/big-decimal.ts
-import * as dn from "dnum";
-var DECIMAL_WIRE = /^-?\d+(?:\.\d+)?$/u;
-function decodeBigDecimal(wire) {
-  if (!DECIMAL_WIRE.test(wire)) {
-    throw new DalpSdkError({
-      code: "sdk.scalar.BIG_DECIMAL_INVALID",
-      category: "sdk.configuration",
-      retryable: false,
-      message: `\`${wire}\` is not a plain decimal string.`,
-      why: "A BigDecimal field carries an unscaled decimal, with no exponent and no separators.",
-      fix: "Pass the value exactly as the API returned it."
-    });
-  }
-  return dn.from(wire);
-}
-var encodeBigDecimal = (value) => dn.toString(value);
-// src/scalars/ethereum-address.ts
-import { getAddress, isAddress } from "viem";
-function decodeEthereumAddress(wire) {
-  if (!isAddress(wire, { strict: false })) {
-    throw new DalpSdkError({
-      code: "sdk.scalar.EVM_ADDRESS_INVALID",
-      category: "sdk.configuration",
-      retryable: false,
-      message: `\`${wire}\` is not an EVM address.`,
-      why: "An EVM address is 42 characters starting with 0x.",
-      fix: "Pass the address exactly as the API returned it."
-    });
-  }
-  return getAddress(wire);
-}
-function tryDecodeEthereumAddress(wire) {
-  if (typeof wire !== "string" || !isAddress(wire, { strict: false })) {
-    return;
-  }
-  return getAddress(wire);
-}
-// src/scalars/organization-id.ts
-function decodeOrganizationId(wire) {
-  if (wire.length === 0) {
-    throw new DalpSdkError({
-      code: "sdk.scalar.ORGANIZATION_ID_INVALID",
-      category: "sdk.configuration",
-      retryable: false,
-      message: "An organization id cannot be empty.",
-      why: "The organization id scopes every tenant-owned request.",
-      fix: "Pass the id the platform returned for the active organization."
-    });
-  }
-  return wire;
-}
-function tryDecodeOrganizationId(wire) {
-  return typeof wire === "string" && wire.length > 0 ? wire : undefined;
-}
-// src/scalars/exchange-rates.ts
-function decodeRow(row) {
-  const source = row !== null && typeof row === "object" ? row : { rate: null, feedAddress: null };
-  const rate = Reflect.get(source, "rate");
-  const feedAddress = Reflect.get(source, "feedAddress");
-  return {
-    ...source,
-    rate: typeof rate === "string" ? decodeBigDecimal(rate) : null,
-    feedAddress: typeof feedAddress === "string" ? decodeEthereumAddress(feedAddress) : null
-  };
-}
-function decodeExchangeRatesListResponse(payload) {
-  const source = payload !== null && typeof payload === "object" ? payload : { data: [] };
-  const rows = Reflect.get(source, "data");
-  return { ...source, data: Array.isArray(rows) ? rows.map(decodeRow) : [] };
-}
-var exchangeRatesListTransformer = async (data) => decodeExchangeRatesListResponse(data);
-export {
-  decodeBigDecimal,
-  decodeEthereumAddress,
-  decodeExchangeRatesListResponse,
-  decodeOrganizationId,
-  encodeBigDecimal,
-  exchangeRatesListTransformer,
-  tryDecodeEthereumAddress,
-  tryDecodeOrganizationId
-};

package/dist/scalars/organization-id.d.ts

@@ -1,20 +0,0 @@
-/**
- * Branded organization id: the only entity id branded end to end across the
- * platform. Runtime validation is minimal; the brand is the type-level
- * contract.
- *
- * @module
- */
-export type OrganizationIdValue = string & {
-    readonly __brand: "OrganizationId";
-};
-/** Brand a non-empty organization id. */
-export declare function decodeOrganizationId(wire: string): OrganizationIdValue;
-/**
- * Brand an organization id, or return nothing when it is not one.
- *
- * The mirror of {@link decodeOrganizationId} for callers that need a verdict
- * rather than an exception, which is what the previous schema's `safeParse`
- * gave them.
- */
-export declare function tryDecodeOrganizationId(wire: unknown): OrganizationIdValue | undefined;

package/dist/secret.d.ts

@@ -1,14 +0,0 @@
-export declare const SECRET_REDACTION_MARKER = "[REDACTED]";
-declare const inspectSymbol: unique symbol;
-/** Opaque secret value which cannot leak through common serialization paths. */
-export declare class Secret {
-    private constructor();
-    static from(value: string): Secret;
-    toString(): string;
-    toJSON(): string;
-    [inspectSymbol](): string;
-}
-export declare const secret: (value: string) => Secret;
-/** Reveal a secret only at the transport header-injection boundary. */
-export declare const unwrapSecret: (value: Secret) => string;
-export {};

package/dist/sign-webhook-receipt.d.ts

@@ -1,76 +0,0 @@
-/**
- * Counter-sign a DALP webhook delivery receipt.
- *
- * The inbound half of webhook signing (`verifyWebhook`) proves a delivery
- * DALP sent is authentic. This is the return half: after a consumer verifies
- * and accepts a delivery, it counter-signs a receipt so the platform has
- * non-repudiation proof the consumer received and acknowledged that specific
- * delivery. Submit the result to `POST /api/v2/webhook-receipts`.
- *
- * The canonical signing string and HMAC mirror the server-side implementation,
- * which a published package cannot import. A shared golden test vector pins the
- * output of both so the two copies cannot drift.
- *
- * @module
- */
-/**
- * Scheme tag prefixed to the counter-signed receipt signing string. It
- * domain-separates receipt signatures from inbound delivery signatures and
- * reserves room for a future scheme revision.
- */
-export declare const RECEIPT_SIGNING_SCHEME = "dalp.whr.v1";
-/** The delivery tuple a receipt signature binds. */
-export interface ReceiptSigningTuple {
-    /** The delivery being acknowledged. A retry allocates a fresh `deliveryId`. */
-    deliveryId: string;
-    /** The endpoint that received the delivery. */
-    endpointId: string;
-    /** The event identifier carried by the delivery (`evt_*`). */
-    evtId: string;
-    /** The hash of the delivered event body (`sha256:<hex>`). */
-    innerEventHash: string;
-}
-export interface SignWebhookReceiptInput extends ReceiptSigningTuple {
-    /** The endpoint signing secret (`dalp_whsk_...`); the prefix is stripped for you. */
-    secret: string;
-}
-/**
- * Build the canonical string a consumer HMACs to counter-sign a receipt.
- *
- * Binding the signature to the full delivery tuple, not just the event body
- * hash, is what closes the receipt-replay window: a retry allocates a fresh
- * `deliveryId` for the same event, so a signature minted for one attempt
- * produces a different signing string than another attempt and no longer
- * verifies against it.
- *
- * Newline-joined is unambiguous because every field carries no newline:
- * `deliveryId`/`endpointId` are UUIDs, `evtId` is the server-issued `evt_*`
- * identifier, and `innerEventHash` is `sha256:<hex>`.
- */
-export declare function buildReceiptSigningString(tuple: Readonly<ReceiptSigningTuple>): string;
-/**
- * Counter-sign a webhook delivery receipt.
- *
- * Returns the lowercase hex `HMAC-SHA256(key, signingString)` to submit as the
- * receipt's `consumerSignature`. The key is the base64-decoded prefix-stripped
- * secret, the same derivation the Standard Webhooks library uses for inbound
- * delivery verification (`verifyWebhook`) and that the dispatcher signs with —
- * so the receipt and the delivery share key material.
- *
- * @example
- * ```typescript
- * const consumerSignature = signWebhookReceipt({
- *   deliveryId,
- *   endpointId,
- *   evtId,
- *   innerEventHash,
- *   secret, // the endpoint's dalp_whsk_... signing secret
- * });
- * ```
- */
-export declare function signWebhookReceipt({ secret, ...tuple }: Readonly<SignWebhookReceiptInput>): string;
-export interface VerifyWebhookReceiptInput extends SignWebhookReceiptInput {
-    readonly signature: string;
-}
-/** Verify a counter-signed receipt without leaking signature timing. */
-export declare function verifyWebhookReceipt({ signature, ...input }: Readonly<VerifyWebhookReceiptInput>): boolean;

package/dist/sign-webhook-receipt.js

@@ -1,26 +0,0 @@
-import {
-  toStandardWebhookSecret
-} from "./chunk-r0vsftj4.js";
-
-// src/sign-webhook-receipt.ts
-import { createHmac, timingSafeEqual } from "node:crypto";
-var RECEIPT_SIGNING_SCHEME = "dalp.whr.v1";
-function buildReceiptSigningString(tuple) {
-  return [RECEIPT_SIGNING_SCHEME, tuple.deliveryId, tuple.endpointId, tuple.evtId, tuple.innerEventHash].join(`
-`);
-}
-function signWebhookReceipt({ secret, ...tuple }) {
-  const key = Buffer.from(toStandardWebhookSecret(secret), "base64");
-  return createHmac("sha256", key).update(buildReceiptSigningString(tuple), "utf8").digest("hex");
-}
-function verifyWebhookReceipt({ signature, ...input }) {
-  const expected = Buffer.from(signWebhookReceipt(input), "hex");
-  const received = Buffer.from(signature, "hex");
-  return expected.length === received.length && timingSafeEqual(expected, received);
-}
-export {
-  RECEIPT_SIGNING_SCHEME,
-  buildReceiptSigningString,
-  signWebhookReceipt,
-  verifyWebhookReceipt
-};

package/dist/transport/cookie-store.d.ts

@@ -1,9 +0,0 @@
-export type CookieStoreFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-export interface CookieStoreShape {
-    readonly header: () => string;
-    readonly isEmpty: () => boolean;
-    readonly setCookieHeader: (header: string) => void;
-    readonly storeSetCookieHeaders: (headers: ReadonlyArray<string>) => void;
-}
-export declare function makeCookieStore(initialHeader?: string): CookieStoreShape;
-export declare function createCookieStoreFetch(cookieStore: CookieStoreShape, fetchImpl?: CookieStoreFetch): CookieStoreFetch;

package/dist/transport/sse-lifecycle.d.ts

@@ -1,44 +0,0 @@
-export type SseEventDisposition = "continue" | "success" | "failure";
-export interface SseStreamResult<T> {
-    readonly stream: AsyncIterable<T>;
-}
-export interface SseLifecycleOptions<T> {
-    readonly connect: (signal: AbortSignal) => Promise<SseStreamResult<T>>;
-    readonly classify: (event: T) => SseEventDisposition;
-    readonly signal?: AbortSignal;
-    readonly onEvent?: (event: T) => void;
-    /**
-     * Opt into a bounded attempt count instead of the wall-clock window. Only
-     * for callers that genuinely want "n tries and stop" — a count is a poor
-     * budget when every failure is instant, because a single multi-second
-     * backend stall spends it all in a few hundred milliseconds.
-     */
-    readonly maxReconnects?: number;
-    /**
-     * How long to keep reconnecting through an unbroken run of failures, in
-     * wall-clock milliseconds. The window is anchored at the first failure of a
-     * streak and restarts only after a connection stays up for
-     * `healthyConnectionMs`, so a long-lived stream that dies late still gets a
-     * full window.
-     */
-    readonly reconnectWindowMs?: number;
-    /**
-     * How long a connection must stay up to count as recovered and clear the
-     * failure streak. Receiving events is deliberately *not* the test: a stream
-     * that replays its opening frame on every subscription would clear the
-     * streak on each attempt and reconnect forever.
-     */
-    readonly healthyConnectionMs?: number;
-    readonly initialBackoffMs?: number;
-    readonly maxBackoffMs?: number;
-    readonly sleep?: (milliseconds: number) => Promise<void>;
-    readonly now?: () => number;
-}
-export type SseLifecycleFailureReason = "aborted" | "terminal-failure" | "transport-failure";
-export declare class SseLifecycleError<T = unknown> extends Error {
-    readonly reason: SseLifecycleFailureReason;
-    readonly lastEvent?: T;
-    constructor(reason: SseLifecycleFailureReason, lastEvent?: T, options?: ErrorOptions);
-}
-/** Add terminal-state semantics to a generated Hey API SSE stream. */
-export declare function consumeSseUntilTerminal<T>(options: SseLifecycleOptions<T>): Promise<T>;

package/dist/verify-webhook.js

@@ -1,8 +0,0 @@
-import {
-  toStandardWebhookSecret,
-  verifyWebhook
-} from "./chunk-r0vsftj4.js";
-export {
-  toStandardWebhookSecret,
-  verifyWebhook
-};

package/dist/wait-for-transaction.js

@@ -1,120 +0,0 @@
-import {
-  PAUSED_POLL_INTERVAL_MAX_MS,
-  readsAsFundingPaused
-} from "./chunk-fjnq61hj.js";
-
-// src/wait-for-transaction.ts
-var failedStates = new Set(["FAILED", "DEAD_LETTER", "CANCELLED"]);
-var isWaitForTransactionSuccess = (status) => status.status === "COMPLETED";
-
-class DalpTransactionWaitError extends Error {
-  code = "sdk.transaction.WAIT_FAILED";
-  category = "operational";
-  transactionId;
-  reason;
-  lastStatus;
-  elapsedMs;
-  constructor(transactionId, reason, lastStatus, elapsedMs) {
-    let message;
-    if (reason === "terminal-failure") {
-      message = `Transaction ${transactionId} reached terminal state ${lastStatus?.status ?? "UNKNOWN"}`;
-    } else if (reason === "timeout") {
-      message = `Transaction ${transactionId} did not reach a terminal state within ${elapsedMs ?? 0}ms`;
-    } else if (reason === "funding-paused") {
-      message = `Transaction ${transactionId} is paused waiting for a gas funding payment`;
-    } else {
-      message = `Transaction status observation was aborted for transaction ${transactionId}`;
-    }
-    super(message);
-    this.name = "DalpTransactionWaitError";
-    this.transactionId = transactionId;
-    this.reason = reason;
-    this.lastStatus = lastStatus;
-    this.elapsedMs = elapsedMs;
-  }
-  get status() {
-    return this.lastStatus?.status ?? "UNKNOWN";
-  }
-  get subStatus() {
-    return this.lastStatus?.subStatus ?? null;
-  }
-  get retryable() {
-    return this.reason === "timeout" || this.reason === "funding-paused";
-  }
-}
-var isDalpTransactionWaitError = (error) => error instanceof DalpTransactionWaitError;
-var defaultSleep = (milliseconds, signal) => new Promise((resolve, reject) => {
-  if (signal?.aborted === true) {
-    reject(signal.reason);
-    return;
-  }
-  const onAbort = () => {
-    clearTimeout(timeout);
-    reject(signal?.reason);
-  };
-  const timeout = setTimeout(() => {
-    signal?.removeEventListener("abort", onAbort);
-    resolve();
-  }, milliseconds);
-  signal?.addEventListener("abort", onAbort, { once: true });
-});
-var routeStatusReader = (client) => async (transactionId, signal) => {
-  const result = await client.execute("transaction/status", { transactionId }, signal === undefined ? undefined : { signal });
-  const body = result !== null && typeof result === "object" ? Reflect.get(result, "data") ?? result : result;
-  return body;
-};
-async function waitForTransaction(client, transactionId, options = {}) {
-  const timeoutMs = options.timeoutMs ?? 120000;
-  const pollIntervalMs = options.pollIntervalMs ?? 1000;
-  const now = options.now ?? Date.now;
-  const sleep = options.sleep ?? defaultSleep;
-  const readStatus = options.readStatus ?? routeStatusReader(client);
-  const holdWhilePaused = options.holdWhilePaused ?? true;
-  const waitStartedAt = now();
-  let budgetStartedAt = waitStartedAt;
-  let pollDelayMs = pollIntervalMs;
-  let lastStatus;
-  const isAborted = () => options.signal?.aborted === true;
-  while (true) {
-    if (isAborted()) {
-      throw new DalpTransactionWaitError(transactionId, "aborted", lastStatus);
-    }
-    if (now() - budgetStartedAt >= timeoutMs) {
-      throw new DalpTransactionWaitError(transactionId, "timeout", lastStatus, now() - waitStartedAt);
-    }
-    try {
-      lastStatus = await readStatus(transactionId, options.signal);
-    } catch (error) {
-      if (isAborted()) {
-        throw new DalpTransactionWaitError(transactionId, "aborted", lastStatus);
-      }
-      throw error;
-    }
-    options.onStatus?.(lastStatus);
-    if (failedStates.has(lastStatus.status)) {
-      throw new DalpTransactionWaitError(transactionId, "terminal-failure", lastStatus);
-    }
-    if (isWaitForTransactionSuccess(lastStatus)) {
-      return lastStatus;
-    }
-    if (readsAsFundingPaused(lastStatus)) {
-      if (!holdWhilePaused) {
-        throw new DalpTransactionWaitError(transactionId, "funding-paused", lastStatus, now() - waitStartedAt);
-      }
-      budgetStartedAt = now();
-      pollDelayMs = Math.min(pollDelayMs * 2, Math.max(pollIntervalMs, PAUSED_POLL_INTERVAL_MAX_MS));
-    } else {
-      pollDelayMs = pollIntervalMs;
-    }
-    try {
-      await sleep(Math.min(pollDelayMs, Math.max(0, timeoutMs - (now() - budgetStartedAt))), options.signal);
-    } catch {
-      throw new DalpTransactionWaitError(transactionId, "aborted", lastStatus);
-    }
-  }
-}
-export {
-  DalpTransactionWaitError,
-  isDalpTransactionWaitError,
-  waitForTransaction
-};