@settlemint/dalp-sdk 3.1.15 → 3.1.16-main.33748846737

package/dist/scalars/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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

@@ -0,0 +1,86 @@
+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

@@ -0,0 +1,20 @@
+/**
+ * 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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,76 @@
+/**
+ * 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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,44 @@
+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/types.d.ts

@@ -1,110 +1,73 @@
 /**
- * Type-only exports for the DALP SDK.
+ * Generated request, response, and model types for the v2 surface.
  *
- * Import from `@settlemint/dalp-sdk/types` when you only need types
- * (e.g., for function signatures) without pulling in runtime code.
- *
- * Related: kit/sdk/src/client.ts
+ * Type-only by construction — the emitted JavaScript is empty, so a consumer
+ * that imports only types pays nothing at runtime. The dist completeness
+ * graph accepts that empty file when `dist/types.d.ts` is present.
  *
  * @module
  */
-import type { ContractRouterClient } from "@orpc/contract";
-import type { JsonifiedClient } from "@orpc/openapi-client";
-import type { rpcContract } from "./contract.js";
-/**
- * Fully typed DALP API client.
- *
- * Uses `JsonifiedClient` because the SDK communicates via the OpenAPI/REST
- * endpoint where values are serialized as standard JSON (e.g., Date → string,
- * BigInt → string).
- *
- * Provides auto-completed access to all v2 API namespaces:
- * `account`, `actions`, `addons`, `admin`, `contacts`, `exchangeRates`,
- * `externalToken`, `identityRecovery`, `monitoring`, `search`,
- * `settings`, `system`, `token`, `transaction`, `user`.
- */
-export type DalpClient = JsonifiedClient<ContractRouterClient<typeof rpcContract, DalpClientCallContext>>;
-/**
- * Per-call client context threaded into individual SDK operations as the second
- * argument, e.g. `client.token.create(input, { context: { idempotencyKey } })`.
- * Every field is optional and scoped to the single call, unlike the client-level
- * {@link BaseDalpClientConfig.idempotencyKey} which applies to every request.
- */
-export interface DalpClientCallContext {
-    /**
-     * Idempotency key sent as the `Idempotency-Key` header for this call only,
-     * overriding any client-level key. Use a fresh value per genuine retry of a
-     * failed mutation: dapi burns the key of a failed transaction, so re-sending
-     * under the same key is rejected ("previously failed. Use a new idempotency
-     * key to retry"). A stable value within one logical attempt keeps network-level
-     * fetch retries deduplicated.
-     */
-    idempotencyKey?: string;
-    /**
-     * oRPC error codes the caller treats as expected for this call and does not
-     * want surfaced by its own error logging (e.g. an existence probe that accepts
-     * `NOT_FOUND`). A client-side hint scoped to the single call; it is not sent to
-     * the server.
-     */
-    skipLoggingFor?: readonly string[];
-}
-interface BaseDalpClientConfig {
-    /** Base URL of the DALP API (e.g., `"https://dalp.example.com"`). */
-    url: string;
-    /**
-     * Organization ID for multi-tenant setups.
-     * Required when the API key is scoped to multiple organizations.
-     */
-    organizationId?: string;
-    /**
-     * Additional headers merged into every request.
-     * Accepts a static object or a (possibly async) function for dynamic headers.
-     * Can override defaults like `User-Agent` but cannot override security headers (`x-api-key`, `x-organization-id`).
-     */
-    headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
-    /**
-     * Validate outgoing requests against the contract before sending.
-     * Catches schema violations client-side for faster feedback.
-     * @defaultValue false
-     */
-    requestValidation?: boolean;
-    /**
-     * Validate incoming responses against the contract.
-     * Useful during development to catch API drift.
-     * @defaultValue false
-     */
-    responseValidation?: boolean;
-    /**
-     * Custom `fetch` implementation.
-     * Use this to inject logging, proxy configuration, or test doubles.
-     */
-    fetch?: typeof globalThis.fetch;
-    /**
-     * Idempotency key sent as the `Idempotency-Key` header on every request.
-     *
-     * **Warning:** This value is sent on _every_ request made by the client.
-     * If you reuse the same client instance for multiple mutations, the server
-     * will deduplicate all but the first — subsequent mutations silently return
-     * the first response. Only set this when the client is used for a single
-     * mutation (e.g., a one-shot script). For multi-mutation workflows, set the
-     * header per-request via the `headers` callback instead.
-     *
-     * When omitted, no idempotency key header is sent.
-     */
-    idempotencyKey?: string;
-}
-/**
- * Configuration for creating an authenticated DALP API client.
- */
-export interface DalpClientConfig extends BaseDalpClientConfig {
-    /** API key for authenticated routes (issued via the DALP dashboard or CLI). */
-    apiKey: string;
+import type { AssumableParticipant, EvmAddress, TokenFeatureDividendYield as TokenFeatureDividendYieldWire, TokenFeatureExternalTransactionFee as TokenFeatureExternalTransactionFeeWire, TokenFeatureFixedTreasuryYield as TokenFeatureFixedTreasuryYieldWire, TokenFeatureHistoricalBalances as TokenFeatureHistoricalBalancesWire, TokenFeatureInterestYield as TokenFeatureInterestYieldWire, TokenFeatureMaturityRedemption as TokenFeatureMaturityRedemptionWire, TokenFeatureTransactionFee as TokenFeatureTransactionFeeWire, TokenFeatureTransactionFeeAccounting as TokenFeatureTransactionFeeAccountingWire, TokenDocumentGetUploadUrlBody, TokenTopicScheme, TokenTrustedIssuer, ThemeLogoUpload, EvmUserEventV2Item, UserEventV2Item, UserEventV2ItemCollectionResponse, UserMe, participantsMultisigDrafts_createInvite_Response, token_create_Request, system_feeds_issuerSigned_create_Request, tokenTopicSchemes_create_Request, tokenTrustedIssuers_create_Request } from "./generated/api-types.d.ts";
+/** Participant kinds returned by the participant search surface. */
+export type ParticipantKind = "person" | "company" | "fund" | "spv" | "department" | "joint_account" | "asset" | "organisation" | "claim_issuer" | "addon";
+/** Address projection requested from participant search. */
+export type ParticipantAddressPurpose = "transfer" | "identity" | "participant";
+/** Token eligibility filter accepted by participant search. */
+export interface EligibleForTokenFilter {
+    readonly tokenAddress: EvmAddress;
+    readonly action: "mint" | "transfer" | "burn";
+    readonly reveal?: boolean;
 }
+/** Current ability to act as an assumable participant. */
+export type ActAvailability = AssumableParticipant["actAvailability"];
+/** Stable onboarding flags returned with the current user. */
+export type OnboardingState = UserMe["onboardingState"];
 /**
- * Configuration for creating a public DALP API client.
+ * One row of the authenticated user's event feed, on whichever ledger produced it.
+ *
+ * Discriminated on `family`. Narrow before reading anything else: `blockNumber`,
+ * `transactionHash`, `gasUsed` and `gasPrice` exist only on the `evm` arm, and
+ * `ledgerOffset`, `updateId` and `nodeId` only on the `canton` one.
  */
-export interface PublicDalpClientConfig extends BaseDalpClientConfig {
-    apiKey?: undefined;
-}
-export type { WalletAuthEndpointPath } from "./auth-wallet-plugins.js";
-//# sourceMappingURL=types.d.ts.map
+export type UserEvent = UserEventV2Item;
+/** The `evm` arm of {@link UserEvent}: one indexed contract event. */
+export type EvmUserEvent = EvmUserEventV2Item;
+/** One page of the authenticated user's event feed, across both chain families. */
+export type UserEventCollectionResponse = UserEventV2ItemCollectionResponse;
+/** One decoded name/value entry attached to a user activity event. */
+export type UserEventValue = NonNullable<EvmUserEvent["values"]>[number];
+/** Registry tier from which a topic scheme was inherited. */
+export type TokenTopicSchemeInheritanceLevel = TokenTopicScheme["inheritanceLevel"];
+/** Registry tier from which a trusted issuer was inherited. */
+export type TokenTrustedIssuerInheritanceLevel = TokenTrustedIssuer["inheritanceLevel"];
+/** Body accepted when a token-level topic scheme is created. */
+export type TokenTopicSchemeCreateInput = tokenTopicSchemes_create_Request;
+/** Body accepted when a token-level trusted issuer is created. */
+export type TokenTrustedIssuerCreateInput = tokenTrustedIssuers_create_Request;
+/** Successful token returned when a multisig invite is created. */
+export type MultisigDraftCreateInviteOutput = participantsMultisigDrafts_createInvite_Response;
+/** Body accepted when an issuer-signed scalar feed is created. */
+export type IssuerSignedCreateInput = system_feeds_issuerSigned_create_Request;
+/** Image slot accepted by the theme logo upload endpoints. */
+export type ThemeLogoMode = ThemeLogoUpload["mode"];
+/** Config carried by an attached historical-balances feature. */
+export type TokenFeatureHistoricalBalancesConfig = NonNullable<TokenFeatureHistoricalBalancesWire>;
+/** Config carried by an attached maturity-redemption feature. */
+export type TokenFeatureMaturityRedemptionConfig = NonNullable<TokenFeatureMaturityRedemptionWire>;
+/** Config carried by an attached fixed-treasury-yield feature. */
+export type TokenFeatureFixedTreasuryYieldConfig = NonNullable<TokenFeatureFixedTreasuryYieldWire>;
+/** Config carried by an attached dividend-yield feature. */
+export type TokenFeatureDividendYieldConfig = NonNullable<TokenFeatureDividendYieldWire>;
+/** Config carried by an attached interest-yield feature. */
+export type TokenFeatureInterestYieldConfig = NonNullable<TokenFeatureInterestYieldWire>;
+/** Config carried by an attached transaction-fee feature. */
+export type TokenFeatureTransactionFeeConfig = NonNullable<TokenFeatureTransactionFeeWire>;
+/** Config carried by an attached transaction-fee-accounting feature. */
+export type TokenFeatureTransactionFeeAccountingConfig = NonNullable<TokenFeatureTransactionFeeAccountingWire>;
+/** Config carried by an attached external-transaction-fee feature. */
+export type TokenFeatureExternalTransactionFeeConfig = NonNullable<TokenFeatureExternalTransactionFeeWire>;
+/** MIME type accepted by token-document upload endpoints. */
+export type TokenDocumentMimeType = TokenDocumentGetUploadUrlBody["mimeType"];
+/** Body accepted by the token-create endpoint. */
+export type TokenCreateInput = token_create_Request;
+export type * from "./generated/api-types.d.ts";

package/dist/url.d.ts

@@ -1,2 +1 @@
 export declare function normalizeDalpBaseUrl(url: string): string;
-//# sourceMappingURL=url.d.ts.map

package/dist/verify-webhook.d.ts

@@ -1,34 +1,23 @@
-import type { Webhook } from "./webhook-events.js";
-export type WebhookVerificationFailure = "TIMESTAMP_SKEW" | "SECRET_MISMATCH" | "BODY_HASH_MISMATCH";
+import type { Webhook } from "./webhook-events.ts";
+export type WebhookVerificationFailure = "TIMESTAMP_SKEW" | "SECRET_MISMATCH" | "BODY_HASH_MISMATCH" | "REPLAYED_EVENT" | "MALFORMED_BODY" | "REPLAY_STORE_FAILURE";
 export type WebhookVerificationResult = {
-    ok: true;
-    event: Webhook.Event;
+    readonly ok: true;
+    readonly event: Webhook.Event;
 } | {
-    ok: false;
-    code: WebhookVerificationFailure;
+    readonly ok: false;
+    readonly code: WebhookVerificationFailure;
 };
+export interface WebhookReplayStore {
+    readonly has: (eventId: string) => boolean | Promise<boolean>;
+    readonly add: (eventId: string) => void | Promise<void>;
+}
 export interface VerifyWebhookInput {
-    rawBody: string | Uint8Array;
-    headers: Headers | Record<string, string | string[] | undefined>;
-    secret: string | readonly string[];
+    readonly rawBody: string | Uint8Array;
+    readonly headers: Headers | Record<string, string | ReadonlyArray<string> | undefined>;
+    readonly secret: string | ReadonlyArray<string>;
+    readonly replayStore?: WebhookReplayStore;
+    readonly now?: number | Date;
+    readonly timestampToleranceSeconds?: number;
 }
-/**
- * Strip the `dalp_whsk_` family prefix from a DALP signing secret.
- *
- * The Standard Webhooks library expects the bare secret material; DALP
- * adds the prefix for parity with the `sm_dalp_` API-key family. Both
- * the dispatcher (DALP-side) and any verifier (DALP or consumer) must
- * call this before constructing a `new Webhook(...)` instance, otherwise
- * the HMAC inputs differ on the two ends and every signature mismatches.
- */
 export declare function toStandardWebhookSecret(secret: string): string;
-/**
- * Verifies a DALP webhook signature and returns the typed event union.
- *
- * Use the returned lifecycle state and `supersedes` accessor to reconcile
- * cached DAPI mutation responses with later on-chain outcomes.
- *
- * @see ../../kit/docs/content/events/idempotency-and-on-chain-outcome.mdx
- */
-export declare function verifyWebhook({ rawBody, headers, secret }: VerifyWebhookInput): WebhookVerificationResult;
-//# sourceMappingURL=verify-webhook.d.ts.map
+export declare function verifyWebhook(input: VerifyWebhookInput): Promise<WebhookVerificationResult>;

package/dist/verify-webhook.js

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

package/dist/version.d.ts

@@ -2,4 +2,3 @@
 export declare const SDK_VERSION: string;
 /** Default User-Agent header sent with every SDK request. */
 export declare const SDK_USER_AGENT: string;
-//# sourceMappingURL=version.d.ts.map