@settlemint/dalp-sdk 3.1.10 → 3.1.11-main.33538712635

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,75 @@
 /**
- * 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, CollectionFacetEntry, 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, V2ParticipantsMultisigDraftsCreateInviteResponse, V2TokenCreateData, V2SystemFeedsIssuerSignedCreateData, V2TokenTopicSchemesCreateData, V2TokenTrustedIssuersCreateData } from "./generated/types.gen.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 = V2TokenTopicSchemesCreateData["body"];
+/** Body accepted when a token-level trusted issuer is created. */
+export type TokenTrustedIssuerCreateInput = V2TokenTrustedIssuersCreateData["body"];
+/** Successful token returned when a multisig invite is created. */
+export type MultisigDraftCreateInviteOutput = V2ParticipantsMultisigDraftsCreateInviteResponse;
+/** Body accepted when an issuer-signed scalar feed is created. */
+export type IssuerSignedCreateInput = V2SystemFeedsIssuerSignedCreateData["body"];
+/** Image slot accepted by the theme logo upload endpoints. */
+export type ThemeLogoMode = ThemeLogoUpload["mode"];
+/** Facet counts keyed by collection field id. */
+export type CollectionFacets = Record<string, Array<CollectionFacetEntry>>;
+/** 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 = V2TokenCreateData["body"];
+export type * from "./generated/types.gen.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

package/dist/wait-for-transaction.d.ts

@@ -1,94 +1,48 @@
-/**
- * Bounded wait-until-terminal barrier for queued DALP mutations.
- *
- * A v2 mutation may return a `202`-style async-accepted envelope when its
- * synchronous wait window elapses while the execution workflow is still
- * confirming. `waitForTransaction` turns that into a deterministic outcome:
- * poll the transaction status route at a FIXED interval bounded by a wall-clock
- * deadline, resolve on a terminal success, throw a typed error on a terminal
- * failure, and throw a loud timeout error if the deadline elapses first.
- *
- * This is a determinism barrier, not a masking retry — total wait is bounded by
- * `timeoutMs` (never exponential), and a never-terminating transaction fails
- * loud and bounded instead of hanging.
- *
- * Related: kit/sdk/src/types.ts
- * Related: packages/dalp/api-contract/src/routes/transaction/routes/transaction.status.schema.ts
- *
- * @module
- */
-import type { DalpClient } from "./types.js";
-/** Outcome shape returned by the transaction status route, narrowed to the fields this helper reads. */
-export interface WaitForTransactionResult {
-    readonly tokenAddress?: unknown;
+import type { Client } from "./generated/client/types.gen.ts";
+import type { EvmTransactionStatusOutput } from "./generated/types.gen.ts";
+export interface WaitForTransactionContractError {
+    readonly id: string;
+    readonly args: Readonly<Record<string, string>>;
+    readonly why: string;
+    readonly message: string;
+    readonly fix?: string;
 }
 export interface WaitForTransactionStatus {
-    transactionId: string;
-    status: string;
-    subStatus: string | null;
-    transactionHash: string | null;
-    errorMessage: string | null;
-    result?: WaitForTransactionResult;
+    readonly transactionId: string;
+    readonly status: string;
+    readonly subStatus: string | null;
+    readonly transactionHash: string | null;
+    readonly errorMessage: string | null;
+    readonly contractError?: WaitForTransactionContractError | null;
+    readonly result?: WaitForTransactionResult;
+}
+/** Kind-scoped terminal result from the generated transaction status contract. */
+export type WaitForTransactionResult = NonNullable<EvmTransactionStatusOutput["result"]>;
+export interface WaitForTransactionSuccess extends WaitForTransactionStatus {
+    readonly status: "COMPLETED";
 }
 export interface WaitForTransactionOptions {
-    /** Wall-clock ceiling for the whole wait, in milliseconds. Default 120_000. */
-    timeoutMs?: number;
-    /** Fixed delay between status polls, in milliseconds. Default 2_000. */
-    intervalMs?: number;
-    /**
-     * Resolve (instead of continuing to poll) when the transaction reaches
-     * `PENDING_APPROVAL` — an external approval gate (DFNS / Fireblocks) that is
-     * not a stall and may legitimately outlast the deadline. Default `true`.
-     */
-    resolveOnPendingApproval?: boolean;
-    /**
-     * Cancels the wait when the owning context (React component, request handler,
-     * workflow step) is torn down. An aborted signal stops the loop on the next
-     * iteration, cancels the in-flight status request, and surfaces as a
-     * {@link DalpTransactionWaitError} with `reason: "aborted"`.
-     */
-    signal?: AbortSignal;
+    readonly timeoutMs?: number;
+    readonly pollIntervalMs?: number;
+    readonly signal?: AbortSignal;
+    readonly onStatus?: (status: WaitForTransactionStatus) => void;
+    readonly now?: () => number;
+    readonly sleep?: (milliseconds: number, signal?: AbortSignal) => Promise<void>;
+    readonly readStatus?: (transactionId: string, signal?: AbortSignal) => Promise<WaitForTransactionStatus>;
 }
-/**
- * Thrown when a transaction reaches a terminal failure state
- * (`FAILED` / `DEAD_LETTER` / `CANCELLED`), does not reach any terminal state
- * within the deadline (`reason: "timeout"`), or the caller's `AbortSignal`
- * fires (`reason: "aborted"`).
- */
+export type TransactionWaitFailureReason = "terminal-failure" | "timeout" | "aborted";
 export declare class DalpTransactionWaitError extends Error {
+    readonly code = "sdk.transaction.WAIT_FAILED";
+    readonly category: "operational";
     readonly transactionId: string;
-    readonly status: string;
-    readonly subStatus: string | null;
-    readonly reason: "terminal-failure" | "timeout" | "aborted";
-    readonly lastStatus: WaitForTransactionStatus | undefined;
-    constructor(options: {
-        message: string;
-        transactionId: string;
-        status: string;
-        subStatus: string | null;
-        reason: "terminal-failure" | "timeout" | "aborted";
-        lastStatus?: WaitForTransactionStatus;
-        cause?: unknown;
-    });
+    readonly reason: TransactionWaitFailureReason;
+    readonly lastStatus?: WaitForTransactionStatus;
+    readonly elapsedMs?: number;
+    constructor(transactionId: string, reason: TransactionWaitFailureReason, lastStatus?: WaitForTransactionStatus, elapsedMs?: number);
+    get status(): string;
+    get subStatus(): string | null;
+    get retryable(): boolean;
 }
-/**
- * Poll the transaction status route until the transaction reaches a terminal
- * state or the deadline elapses.
- *
- * - `COMPLETED` → resolves with the final status (the handler already waited for
- *   the indexer drain, so this is a true read-after-write guarantee).
- * - `FAILED` / `DEAD_LETTER` / `CANCELLED` → throws {@link DalpTransactionWaitError}
- *   (`reason: "terminal-failure"`) carrying `status`, `subStatus`, and
- *   `errorMessage` — fail fast, do not keep polling.
- * - `PENDING_APPROVAL` → resolves as pending (when `resolveOnPendingApproval`,
- *   the default) so an external approval gate is never treated as a stall.
- * - deadline elapsed → throws {@link DalpTransactionWaitError} (`reason: "timeout"`)
- *   carrying the last observed status — a loud, bounded failure, never an
- *   indefinite hang.
- *
- * @param client A DALP API client.
- * @param transactionId The queue transaction identifier (UUIDv7) returned in the
- *   async-accepted envelope.
- */
-export declare function waitForTransaction(client: DalpClient, transactionId: string, options?: WaitForTransactionOptions): Promise<WaitForTransactionStatus>;
-//# sourceMappingURL=wait-for-transaction.d.ts.map
+export declare const isDalpTransactionWaitError: (error: unknown) => error is DalpTransactionWaitError;
+/** Poll transaction status until a terminal verdict, timeout, or abort. */
+export declare function waitForTransaction(client: Client, transactionId: string, options?: WaitForTransactionOptions): Promise<WaitForTransactionSuccess>;