@settlemint/dalp-sdk 3.1.18 → 3.1.19-main.34482536277

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

@@ -1,94 +1,81 @@
-/**
- * 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 { DalpClient } from "./proxy/client.ts";
+import type { EvmTransactionStatusOutput } from "./generated/api-types.d.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;
+    /** The open funding ask a write parked by the funding gate is waiting on. */
+    readonly activeRequirement?: EvmTransactionStatusOutput["activeRequirement"];
+    /** The chain and block an index rebuild must reach before this write reads back. */
+    readonly indexerRebuild?: EvmTransactionStatusOutput["indexerRebuild"];
+}
+/** 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;
+    readonly timeoutMs?: number;
+    readonly pollIntervalMs?: number;
+    readonly signal?: AbortSignal;
+    readonly onStatus?: (status: WaitForTransactionStatus) => void;
     /**
-     * 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`.
+     * Whether the wait outlasts a funding pause. True, the default, restarts the
+     * timeout on every status that reports an open funding ask, so the wait ends
+     * only when the ask is paid or the platform fails the request. False ends
+     * the wait on the first such status with reason `funding-paused`, for a
+     * caller that shows the write as pending and lets the payment land on its
+     * own time.
      */
-    resolveOnPendingApproval?: boolean;
+    readonly holdWhilePaused?: 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"`.
+     * Whether the wait outlasts an index rebuild. True, the default, restarts the
+     * timeout on every status that reports a rebuild, so the wait ends only when
+     * the replay reaches the write's block or the platform fails the request.
+     * False ends the wait on the first such status with reason `indexer-rebuild`,
+     * for a caller that would rather come back later than hold a connection open
+     * for the hours a replay takes.
      */
-    signal?: AbortSignal;
+    readonly holdWhileRebuilding?: boolean;
+    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" | "funding-paused" | "indexer-rebuild";
 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;
 }
+export declare const isDalpTransactionWaitError: (error: unknown) => error is DalpTransactionWaitError;
 /**
- * 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.
+ * Poll transaction status until a terminal verdict, timeout, or abort.
  *
- * @param client A DALP API client.
- * @param transactionId The queue transaction identifier (UUIDv7) returned in the
- *   async-accepted envelope.
+ * The timeout measures the platform's progress. A status that reports an
+ * open funding ask restarts it, so a write parked on an operator payment is
+ * never reported as a timeout and a resumed write gets its whole budget back.
+ * A status that reports an index rebuild restarts it for the same reason: the
+ * write is already on chain and the platform is replaying that chain's history
+ * before it can be read back. `holdWhilePaused: false` and
+ * `holdWhileRebuilding: false` end the wait on those statuses instead. The
+ * `elapsedMs` a timeout carries is the whole wait, pauses included.
  */
-export declare function waitForTransaction(client: DalpClient, transactionId: string, options?: WaitForTransactionOptions): Promise<WaitForTransactionStatus>;
-//# sourceMappingURL=wait-for-transaction.d.ts.map
+export declare function waitForTransaction(client: DalpClient, transactionId: string, options?: WaitForTransactionOptions): Promise<WaitForTransactionSuccess>;

package/dist/wait-for-transaction.js

@@ -0,0 +1,142 @@
+import {
+  readsAsIndexerRebuild2
+} from "./chunk-sk9nc2q3.js";
+
+// src/reads-as-funding-paused.ts
+function readsAsFundingPaused(status) {
+  if (status === null || typeof status !== "object") {
+    return false;
+  }
+  const requirement = Reflect.get(status, "activeRequirement");
+  return requirement !== undefined && requirement !== null;
+}
+var PAUSED_POLL_INTERVAL_MAX_MS = 30000;
+
+// 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 if (reason === "indexer-rebuild") {
+      const chainId = lastStatus?.indexerRebuild?.chainId;
+      message = `Transaction ${transactionId} is on chain, and the platform is still rebuilding its index of chain ${chainId ?? "unknown"} before the write can be read back`;
+    } 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" || this.reason === "indexer-rebuild";
+  }
+}
+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 holdWhileRebuilding = options.holdWhileRebuilding ?? 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;
+    }
+    let parkedBy;
+    let holdsThroughIt = false;
+    if (readsAsFundingPaused(lastStatus)) {
+      parkedBy = "funding-paused";
+      holdsThroughIt = holdWhilePaused;
+    } else if (readsAsIndexerRebuild2(lastStatus)) {
+      parkedBy = "indexer-rebuild";
+      holdsThroughIt = holdWhileRebuilding;
+    }
+    if (parkedBy === undefined) {
+      pollDelayMs = pollIntervalMs;
+    } else {
+      if (!holdsThroughIt) {
+        throw new DalpTransactionWaitError(transactionId, parkedBy, lastStatus, now() - waitStartedAt);
+      }
+      budgetStartedAt = now();
+      pollDelayMs = Math.min(pollDelayMs * 2, Math.max(pollIntervalMs, PAUSED_POLL_INTERVAL_MAX_MS));
+    }
+    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
+};

package/dist/webhook-events.d.ts

@@ -1,7 +1,7 @@
 /**
  * Generated webhook event types.
  *
- * Do not edit by hand. Run `bun run tools/scripts/generate-webhook-events-sdk.ts`.
+ * Do not edit by hand. Run `bun run --cwd kit/sdk codegen:webhook-events-sdk`.
  *
  * @module
  */
@@ -13,7 +13,7 @@ export declare namespace Webhook {
      * Adds `supersedes` only to lifecycle states that can authoritatively replace
      * an earlier event.
      *
-     * @see ../../kit/docs/content/events/idempotency-and-on-chain-outcome.mdx
+     * @see ../../../kit/docs/content/events/idempotency-and-on-chain-outcome.mdx
      */
     type SupersedesAccessor<TState extends LifecycleState> = TState extends SupersedingLifecycleState ? {
         readonly supersedes: string;
@@ -34,44 +34,44 @@ export declare namespace Webhook {
     } & SupersedesAccessor<TState>;
     type AccessControlRoleGrantedProvisionalV1 = EventEnvelope<"access-control.role-granted.provisional", 1, "provisional", {
         readonly accessManagerAddress: string;
-        readonly accountAddress: string;
+        readonly accountAddress?: string;
         readonly blockNumber: string;
         readonly chainId: number;
         readonly roleId: string;
-        readonly sender: string;
+        readonly sender?: string;
         readonly systemAddress: string;
         readonly transactionHash: string;
     }>;
     type AccessControlRoleGrantedRetractedV1 = EventEnvelope<"access-control.role-granted.retracted", 1, "retracted", {
         readonly accessManagerAddress: string;
-        readonly accountAddress: string;
+        readonly accountAddress?: string;
         readonly blockNumber: string;
         readonly chainId: number;
         readonly reorgBlockNumber: number;
         readonly roleId: string;
-        readonly sender: string;
+        readonly sender?: string;
         readonly supersedes: string;
         readonly systemAddress: string;
         readonly transactionHash: string;
     }>;
     type AccessControlRoleRevokedProvisionalV1 = EventEnvelope<"access-control.role-revoked.provisional", 1, "provisional", {
         readonly accessManagerAddress: string;
-        readonly accountAddress: string;
+        readonly accountAddress?: string;
         readonly blockNumber: string;
         readonly chainId: number;
         readonly roleId: string;
-        readonly sender: string;
+        readonly sender?: string;
         readonly systemAddress: string;
         readonly transactionHash: string;
     }>;
     type AccessControlRoleRevokedRetractedV1 = EventEnvelope<"access-control.role-revoked.retracted", 1, "retracted", {
         readonly accessManagerAddress: string;
-        readonly accountAddress: string;
+        readonly accountAddress?: string;
         readonly blockNumber: string;
         readonly chainId: number;
         readonly reorgBlockNumber: number;
         readonly roleId: string;
-        readonly sender: string;
+        readonly sender?: string;
         readonly supersedes: string;
         readonly systemAddress: string;
         readonly transactionHash: string;
@@ -79,33 +79,42 @@ export declare namespace Webhook {
     type AssetIssuanceProvisionalV1 = EventEnvelope<"asset.issuance.provisional", 1, "provisional", {
         readonly assetAddress: string;
         readonly chainId: number;
-        readonly issuer: string;
+        readonly issuer?: string;
         readonly quantity: string;
         readonly transactionHash: string;
     }>;
+    type AssetIssuanceRetractedV1 = EventEnvelope<"asset.issuance.retracted", 1, "retracted", {
+        readonly assetAddress: string;
+        readonly chainId: number;
+        readonly issuer?: string;
+        readonly quantity: string;
+        readonly reorgBlockNumber: number;
+        readonly supersedes: string;
+        readonly transactionHash: string;
+    }>;
     type ComplianceFreezeRecalledV1 = EventEnvelope<"compliance.freeze.recalled", 1, "recalled", {
         readonly chainId: number;
-        readonly reasonCode: string;
+        readonly reasonCode?: string;
         readonly recalledBy: string;
-        readonly subjectAddress: string;
+        readonly subjectAddress?: string;
         readonly supersedes: string;
         readonly tokenAddress: string;
     }>;
     type IdentityRegistrationProvisionalV1 = EventEnvelope<"identity.registration.provisional", 1, "provisional", {
-        readonly accountAddress: string;
+        readonly accountAddress?: string;
         readonly blockNumber: string;
         readonly chainId: number;
-        readonly country: number;
+        readonly country?: number;
         readonly identityAddress: string;
         readonly registryAddress: string;
         readonly status: string;
         readonly transactionHash: string;
     }>;
     type IdentityRegistrationRetractedV1 = EventEnvelope<"identity.registration.retracted", 1, "retracted", {
-        readonly accountAddress: string;
+        readonly accountAddress?: string;
         readonly blockNumber: string;
         readonly chainId: number;
-        readonly country: number;
+        readonly country?: number;
         readonly identityAddress: string;
         readonly registryAddress: string;
         readonly reorgBlockNumber: number;
@@ -124,33 +133,42 @@ export declare namespace Webhook {
         readonly amount: string;
         readonly blockNumber: number;
         readonly chainId: number;
-        readonly from: string;
+        readonly from?: string;
         readonly logIndex: number;
-        readonly to: string;
+        readonly to?: string;
         readonly tokenAddress: string;
         readonly transactionHash: string;
     }>;
     type TokenTransferPendingV1 = EventEnvelope<"token.transfer.pending", 1, "pending", {
         readonly amount: string;
         readonly chainId: number;
-        readonly from: string;
-        readonly to: string;
+        readonly from?: string;
+        readonly to?: string;
         readonly tokenAddress: string;
         readonly transactionHash: string;
     }>;
     type TokenTransferRetractedV1 = EventEnvelope<"token.transfer.retracted", 1, "retracted", {
         readonly amount: string;
-        readonly blockNumber?: number;
+        readonly blockNumber: number;
+        readonly chainId: number;
+        readonly from?: string;
+        readonly logIndex: number;
+        readonly reorgBlockNumber: number;
+        readonly supersedes: string;
+        readonly to?: string;
+        readonly tokenAddress: string;
+        readonly transactionHash: string;
+    } | {
+        readonly amount: string;
         readonly chainId: number;
-        readonly from: string;
-        readonly logIndex?: number;
+        readonly from?: string;
         readonly reorgBlockNumber: number;
         readonly supersedes: string;
-        readonly to: string;
+        readonly to?: string;
         readonly tokenAddress: string;
         readonly transactionHash: string;
     }>;
-    type AnyEvent = AccessControlRoleGrantedProvisionalV1 | AccessControlRoleGrantedRetractedV1 | AccessControlRoleRevokedProvisionalV1 | AccessControlRoleRevokedRetractedV1 | AssetIssuanceProvisionalV1 | ComplianceFreezeRecalledV1 | IdentityRegistrationProvisionalV1 | IdentityRegistrationRetractedV1 | SettlementTransferRetractedV1 | TokenTransferFinalV1 | TokenTransferPendingV1 | TokenTransferRetractedV1;
+    type AnyEvent = AccessControlRoleGrantedProvisionalV1 | AccessControlRoleGrantedRetractedV1 | AccessControlRoleRevokedProvisionalV1 | AccessControlRoleRevokedRetractedV1 | AssetIssuanceProvisionalV1 | AssetIssuanceRetractedV1 | ComplianceFreezeRecalledV1 | IdentityRegistrationProvisionalV1 | IdentityRegistrationRetractedV1 | SettlementTransferRetractedV1 | TokenTransferFinalV1 | TokenTransferPendingV1 | TokenTransferRetractedV1;
     type EventType = AnyEvent["type"];
     type Event<TType extends EventType = EventType> = Extract<AnyEvent, {
         readonly type: TType;
@@ -164,4 +182,3 @@ export declare namespace Webhook {
  * without breaking older SDK versions.
  */
 export declare const WEBHOOK_MANIFEST_VERSION = "2026-08-14";
-//# sourceMappingURL=webhook-events.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@settlemint/dalp-sdk",
-  "version": "3.1.18",
+  "version": "3.1.19-main.34482536277",
   "private": false,
   "description": "Fully typed SDK for the DALP tokenization platform API",
   "homepage": "https://settlemint.com",
@@ -19,8 +19,16 @@
     "LICENSE"
   ],
   "type": "module",
+  "sideEffects": [
+    "./src/**"
+  ],
   "exports": {
     "./package.json": "./package.json",
+    "./runtime-exports": {
+      "types": "./dist/runtime-exports.d.ts",
+      "import": "./dist/runtime-exports.js",
+      "default": "./dist/runtime-exports.js"
+    },
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
@@ -31,47 +39,112 @@
       "import": "./dist/types.js",
       "default": "./dist/types.js"
     },
-    "./plugins": {
-      "types": "./dist/plugins/index.d.ts",
-      "import": "./dist/plugins/index.js",
-      "default": "./dist/plugins/index.js"
+    "./scalars": {
+      "types": "./dist/scalars/index.d.ts",
+      "import": "./dist/scalars/index.js",
+      "default": "./dist/scalars/index.js"
+    },
+    "./react-query": {
+      "types": "./dist/react-query.d.ts",
+      "import": "./dist/react-query.js",
+      "default": "./dist/react-query.js"
+    },
+    "./auth": {
+      "types": "./dist/auth.d.ts",
+      "import": "./dist/auth.js",
+      "default": "./dist/auth.js"
+    },
+    "./bundler": {
+      "types": "./dist/bundler.d.ts",
+      "import": "./dist/bundler.js",
+      "default": "./dist/bundler.js"
+    },
+    "./verify-webhook": {
+      "types": "./dist/verify-webhook.d.ts",
+      "import": "./dist/verify-webhook.js",
+      "default": "./dist/verify-webhook.js"
+    },
+    "./wait-for-transaction": {
+      "types": "./dist/wait-for-transaction.d.ts",
+      "import": "./dist/wait-for-transaction.js",
+      "default": "./dist/wait-for-transaction.js"
+    },
+    "./sdk-error": {
+      "types": "./dist/errors/sdk-error.d.ts",
+      "import": "./dist/errors/sdk-error.js",
+      "default": "./dist/errors/sdk-error.js"
+    },
+    "./sign-webhook-receipt": {
+      "types": "./dist/sign-webhook-receipt.d.ts",
+      "import": "./dist/sign-webhook-receipt.js",
+      "default": "./dist/sign-webhook-receipt.js"
+    },
+    "./effect": {
+      "types": "./dist/effect.d.ts",
+      "import": "./dist/effect.js",
+      "default": "./dist/effect.js"
+    },
+    "./routes": {
+      "types": "./dist/routes/index.d.ts",
+      "import": "./dist/routes/index.js",
+      "default": "./dist/routes/index.js"
     }
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "rm -rf dist && bun scripts/build.js && tsgo -p tsconfig.build.json && bun scripts/fix-dts-extensions.js",
-    "publint": "publint run --strict --pack npm",
-    "attw": "attw --pack . --profile esm-only",
-    "publish": "cp ../../LICENSE . && npm publish --ignore-scripts --tag ${TAG:-latest} --access public",
+    "build": "bun scripts/build.ts && bun scripts/check-dts-portability.ts",
+    "codegen": "bun scripts/codegen.ts",
+    "publint": "publint run --strict --pack bun",
+    "attw": "archive=$(bun pm pack --destination \"$PWD\" --quiet | tail -n 1) && attw \"$archive\" --profile esm-only; code=$?; rm -f \"$archive\"; exit $code",
+    "publish": "cp ../../LICENSE . && bun run --cwd ../.. publish-if-absent \"$PWD\"",
     "prepack": "cp ../../LICENSE .",
-    "test": "bun test --parallel=2 tests",
-    "typecheck": "tsgo"
+    "test": "bun --bun vitest run --config node_modules/@tools/vitest-config/vitest.config.mjs --configLoader native --project unit --project browser --testTimeout 30000 tests/unit",
+    "test:coverage": "bun --bun vitest run --config node_modules/@tools/vitest-config/vitest.config.mjs --configLoader native --project unit --project browser --testTimeout 30000 tests/unit --coverage",
+    "lint": "oxlint --deny-warnings .",
+    "typecheck": "tsc -p . && tsc --noEmit -p scripts/tsconfig.json",
+    "check:dts-portability": "bun scripts/check-dts-portability.ts",
+    "check:auth-coverage": "bun scripts/check-auth-coverage.ts",
+    "codegen:webhook-events-sdk": "bun scripts/generate-webhook-events-sdk.ts"
   },
   "dependencies": {
-    "@better-auth/api-key": "1.6.19",
-    "@better-auth/passkey": "1.6.19",
-    "@orpc/client": "1.14.6",
-    "@orpc/contract": "1.14.6",
-    "@orpc/openapi-client": "1.14.6",
-    "better-auth": "1.6.19",
-    "currency-codes": "2.2.0",
-    "date-fns": "4.4.0",
+    "@better-auth/api-key": "1.7.2",
+    "@better-auth/passkey": "1.7.2",
+    "better-auth": "1.7.2",
+    "better-call": "1.4.0",
     "dnum": "2.17.0",
-    "iso-3166": "4.4.0",
-    "standardwebhooks": "1.0.0",
-    "viem": "2.52.2",
-    "zod": "4.4.3"
+    "standardwebhooks": "1.1.1",
+    "viem": "2.56.3"
   },
   "devDependencies": {
-    "@arethetypeswrong/cli": "0.18.3",
-    "@dalp/api-contract": "workspace:*",
-    "@dalp/errors": "workspace:*",
-    "@tools/typescript-config": "workspace:*",
-    "@types/bun": "1.3.14",
-    "publint": "0.3.21",
-    "typescript": "6.0.3"
+    "@arethetypeswrong/cli": "0.18.5",
+    "@core/schema": "3.1.11",
+    "@tanstack/react-query": "5.102.8",
+    "@tools/typescript-config": "3.1.11",
+    "@tools/vitest-config": "3.1.11",
+    "@types/bun": "1.4.0",
+    "effect": "4.0.0-rc.112",
+    "publint": "0.3.24",
+    "typescript": "7.0.2",
+    "vitest": "5.0.0",
+    "zod": "4.5.4"
+  },
+  "peerDependencies": {
+    "@tanstack/react-query": "^5.101.4",
+    "effect": "^4.0.0-rc.112",
+    "zod": "^4.5.4"
+  },
+  "peerDependenciesMeta": {
+    "@tanstack/react-query": {
+      "optional": true
+    },
+    "effect": {
+      "optional": true
+    },
+    "zod": {
+      "optional": true
+    }
   },
   "engines": {
     "node": ">=20"

package/dist/auth-permissions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"auth-permissions.d.ts","sourceRoot":"","sources":["../src/auth-permissions.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,IAAI,EAAuB,MAAM,4BAA4B,CAAC;AAuBhG,eAAO,MAAM,aAAa,EAAE,aAI1B,CAAC;AAEH,eAAO,MAAM,SAAS,EAAE,IAOtB,CAAC;AAEH,eAAO,MAAM,SAAS,EAAE,IAMtB,CAAC;AAEH,eAAO,MAAM,UAAU,EAAE,IAKvB,CAAC"}

package/dist/auth-wallet-plugins.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"auth-wallet-plugins.d.ts","sourceRoot":"","sources":["../src/auth-wallet-plugins.ts"],"names":[],"mappings":"AA6BA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqBK,CAAC;AAEtC,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;CAoBG,CAAC;AAEtC,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;CAmBC,CAAC;AAEtC,KAAK,iBAAiB,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,IAAI,MAAM,IAAI,EAAE,GAAG,IAAI,GAAG,KAAK,CAAC;AAErF,KAAK,0BAA0B,GAC3B,MAAM,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,aAAa,CAAC,GAC3D,MAAM,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC,aAAa,CAAC,GAC7D,MAAM,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAC,aAAa,CAAC,CAAC;AAEpE,yFAAyF;AACzF,MAAM,MAAM,sBAAsB,GAAG,iBAAiB,CAAC,0BAA0B,GAAG,MAAM,CAAC,CAAC"}