@settlemint/dalp-sdk 3.1.17 → 3.1.18-main.33796544973

package/dist/chunk-f4t1bm86.js

@@ -0,0 +1,67 @@
+// src/proxy/builder.ts
+function buildIndex(table) {
+  const root = { children: new Map };
+  for (const id of Object.keys(table.routes)) {
+    let cursor = root;
+    for (const segment of id.split("/")) {
+      let next = cursor.children.get(segment);
+      if (next === undefined) {
+        next = { children: new Map };
+        cursor.children.set(segment, next);
+      }
+      cursor = next;
+    }
+    cursor.routeId = id;
+  }
+  return root;
+}
+function makeNode(node, table, executor, factories, cache) {
+  const cached = cache.get(node);
+  if (cached !== undefined) {
+    return cached;
+  }
+  const route = node.routeId === undefined ? undefined : table.routes[node.routeId];
+  const id = node.routeId;
+  const target = route === undefined || id === undefined ? {} : Object.assign((input, options) => executor(route, id, input, options), {
+    queryOptions: (input, options) => factories.queryOptions(route, id, input, options),
+    mutationOptions: (options) => factories.mutationOptions(route, id, options)
+  });
+  const proxy = new Proxy(target, {
+    get(base, property, receiver) {
+      if (typeof property !== "string") {
+        return Reflect.get(base, property, receiver);
+      }
+      if (Object.hasOwn(base, property) || property in Function.prototype) {
+        return Reflect.get(base, property, receiver);
+      }
+      const child = node.children.get(property);
+      return child === undefined ? undefined : makeNode(child, table, executor, factories, cache);
+    },
+    has(base, property) {
+      return typeof property === "string" && node.children.has(property) || Reflect.has(base, property);
+    },
+    ownKeys(base) {
+      return [...new Set([...Reflect.ownKeys(base), ...node.children.keys()])];
+    },
+    getOwnPropertyDescriptor(base, property) {
+      if (typeof property === "string" && node.children.has(property)) {
+        return {
+          configurable: true,
+          enumerable: true,
+          value: makeNode(node.children.get(property), table, executor, factories, cache)
+        };
+      }
+      return Reflect.getOwnPropertyDescriptor(base, property);
+    }
+  });
+  cache.set(node, proxy);
+  return proxy;
+}
+function buildProxy(table, executor, factories) {
+  return makeNode(buildIndex(table), table, executor, factories, new Map);
+}
+function findRoute(table, id) {
+  return table.routes[id];
+}
+
+export { buildProxy, findRoute };

package/dist/chunk-fjnq61hj.js

@@ -0,0 +1,11 @@
+// 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;
+
+export { readsAsFundingPaused, PAUSED_POLL_INTERVAL_MAX_MS };

package/dist/chunk-h12fatty.js

@@ -0,0 +1,63 @@
+import {
+  createDalpSdkConfigurationError
+} from "./chunk-y0d2c7kp.js";
+
+// src/secret.ts
+var SECRET_REDACTION_MARKER = "[REDACTED]";
+var inspectSymbol = Symbol.for("nodejs.util.inspect.custom");
+var secretValue = new WeakMap;
+
+class Secret {
+  constructor(value) {
+    secretValue.set(this, value);
+    Object.freeze(this);
+  }
+  static from(value) {
+    if (value.trim().length === 0) {
+      throw new TypeError("DALP SDK: a secret value must not be empty.");
+    }
+    return new Secret(value);
+  }
+  toString() {
+    return SECRET_REDACTION_MARKER;
+  }
+  toJSON() {
+    return SECRET_REDACTION_MARKER;
+  }
+  [inspectSymbol]() {
+    return SECRET_REDACTION_MARKER;
+  }
+}
+var secret = (value) => Secret.from(value);
+var unwrapSecret = (value) => {
+  const raw = secretValue.get(value);
+  if (raw === undefined) {
+    throw new TypeError("DALP SDK: cannot unwrap an invalid secret value.");
+  }
+  return raw;
+};
+
+// src/url.ts
+function normalizeDalpBaseUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch (error) {
+    throw createDalpSdkConfigurationError({
+      message: `DALP SDK: invalid url "${url}". Provide a full URL including the protocol (e.g., "https://dalp.example.com").`,
+      why: "The SDK could not parse the configured DALP API URL.",
+      fix: 'Provide a full http:// or https:// URL, for example "https://dalp.example.com".',
+      cause: error
+    });
+  }
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+    throw createDalpSdkConfigurationError({
+      message: `DALP SDK: url must use https:// or http:// protocol, got "${parsed.protocol}".`,
+      why: `The SDK received a URL with the unsupported "${parsed.protocol}" protocol.`,
+      fix: 'Use a DALP API base URL that starts with "https://" or "http://".'
+    });
+  }
+  return `${parsed.origin}${parsed.pathname.replace(/\/+$/, "")}`;
+}
+
+export { SECRET_REDACTION_MARKER, Secret, secret, unwrapSecret, normalizeDalpBaseUrl };

package/dist/chunk-r0vsftj4.js

@@ -0,0 +1,102 @@
+// src/verify-webhook.ts
+import { Webhook as StandardWebhook } from "standardwebhooks";
+var DEFAULT_TIMESTAMP_TOLERANCE_SECONDS = 5 * 60;
+function toStandardWebhookSecret(secret) {
+  return secret.replace(/^dalp_whsk_/u, "");
+}
+async function verifyWebhook(input) {
+  const headers = normalizeHeaders(input.headers);
+  const nowMillis = input.now instanceof Date ? input.now.getTime() : input.now ?? Date.now();
+  const tolerance = input.timestampToleranceSeconds ?? DEFAULT_TIMESTAMP_TOLERANCE_SECONDS;
+  if (!hasFiniteTimestamp(headers) || isOutsideTimestampTolerance(headers, nowMillis, tolerance)) {
+    return { ok: false, code: "TIMESTAMP_SKEW" };
+  }
+  const rawText = typeof input.rawBody === "string" ? input.rawBody : new TextDecoder().decode(input.rawBody);
+  const eventId = headers["webhook-id"];
+  if (eventId !== undefined && await input.replayStore?.has(eventId) === true) {
+    return { ok: false, code: "REPLAYED_EVENT" };
+  }
+  let sawMalformedBody = false;
+  let sawReplayStoreFailure = false;
+  for (const candidate of Array.isArray(input.secret) ? input.secret : [input.secret]) {
+    if (!matchesSignature(candidate, rawText, headers)) {
+      continue;
+    }
+    let event;
+    try {
+      event = JSON.parse(rawText);
+    } catch {
+      sawMalformedBody = true;
+      continue;
+    }
+    if (eventId !== undefined && input.replayStore !== undefined) {
+      try {
+        await input.replayStore.add(eventId);
+      } catch {
+        sawReplayStoreFailure = true;
+        continue;
+      }
+    }
+    return { ok: true, event };
+  }
+  if (sawReplayStoreFailure) {
+    return { ok: false, code: "REPLAY_STORE_FAILURE" };
+  }
+  if (sawMalformedBody) {
+    return { ok: false, code: "MALFORMED_BODY" };
+  }
+  return { ok: false, code: classifySignatureFailure(rawText, headers) };
+}
+function matchesSignature(secret, rawBody, headers) {
+  const eventId = headers["webhook-id"];
+  const timestamp = Number(headers["webhook-timestamp"]);
+  const signatures = headers["webhook-signature"];
+  if (eventId === undefined || !Number.isFinite(timestamp) || signatures === undefined) {
+    return false;
+  }
+  const expected = new StandardWebhook(toStandardWebhookSecret(secret)).sign(eventId, new Date(timestamp * 1000), rawBody);
+  return signatures.split(" ").some((signature) => {
+    const left = new TextEncoder().encode(signature);
+    const right = new TextEncoder().encode(expected);
+    if (left.byteLength !== right.byteLength) {
+      return false;
+    }
+    let difference = 0;
+    for (let index = 0;index < left.byteLength; index += 1) {
+      difference |= (left[index] ?? 0) ^ (right[index] ?? 0);
+    }
+    return difference === 0;
+  });
+}
+function normalizeHeaders(input) {
+  if (input instanceof Headers) {
+    return Object.fromEntries(input.entries());
+  }
+  const headers = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (value !== undefined) {
+      headers[key.toLowerCase()] = typeof value === "string" ? value : value.join(",");
+    }
+  }
+  return headers;
+}
+function hasFiniteTimestamp(headers) {
+  return Number.isFinite(Number(headers["webhook-timestamp"]));
+}
+function isOutsideTimestampTolerance(headers, nowMillis, toleranceSeconds) {
+  const timestamp = Number(headers["webhook-timestamp"]);
+  return Number.isFinite(timestamp) && Math.abs(nowMillis / 1000 - timestamp) > toleranceSeconds;
+}
+function classifySignatureFailure(rawBody, headers) {
+  try {
+    const parsed = JSON.parse(rawBody);
+    if (typeof parsed.evt_id !== "string" || parsed.evt_id !== headers["webhook-id"]) {
+      return "BODY_HASH_MISMATCH";
+    }
+  } catch {
+    return "BODY_HASH_MISMATCH";
+  }
+  return "SECRET_MISMATCH";
+}
+
+export { toStandardWebhookSecret, verifyWebhook };

package/dist/chunk-rzmr29dq.js

@@ -0,0 +1,260 @@
+// src/transport/cookie-store.ts
+var parseCookieHeader = (header) => {
+  const cookies = new Map;
+  for (const part of header.split(";")) {
+    const pair = part.trim();
+    const separator = pair.indexOf("=");
+    if (separator > 0) {
+      cookies.set(pair.slice(0, separator), pair);
+    }
+  }
+  return cookies;
+};
+var isCookieDeletion = (setCookie, now = Date.now()) => {
+  if (/\bmax-age\s*=\s*-?0+\b/iu.test(setCookie) || /\bmax-age\s*=\s*-\d+\b/iu.test(setCookie)) {
+    return true;
+  }
+  const expires = /\bexpires\s*=\s*([^;]+)/iu.exec(setCookie)?.[1];
+  if (expires === undefined) {
+    return false;
+  }
+  const parsed = Date.parse(expires.trim());
+  return !Number.isNaN(parsed) && parsed <= now;
+};
+function makeCookieStore(initialHeader = "") {
+  const cookies = parseCookieHeader(initialHeader);
+  return {
+    header: () => [...cookies.values()].join("; "),
+    isEmpty: () => cookies.size === 0,
+    setCookieHeader: (header) => {
+      cookies.clear();
+      for (const [name, pair] of parseCookieHeader(header)) {
+        cookies.set(name, pair);
+      }
+    },
+    storeSetCookieHeaders: (headers) => {
+      for (const setCookie of headers) {
+        const pair = setCookie.split(";", 1)[0]?.trim() ?? "";
+        const separator = pair.indexOf("=");
+        if (separator <= 0) {
+          continue;
+        }
+        const name = pair.slice(0, separator);
+        if (isCookieDeletion(setCookie)) {
+          cookies.delete(name);
+        } else {
+          cookies.set(name, pair);
+        }
+      }
+    }
+  };
+}
+var getSetCookieHeaders = (headers) => {
+  const { getSetCookie } = headers;
+  if (getSetCookie !== undefined) {
+    return getSetCookie.call(headers);
+  }
+  const value = headers.get("set-cookie");
+  return value === null ? [] : splitCombinedSetCookie(value);
+};
+var splitCombinedSetCookie = (value) => {
+  const cookies = [];
+  const lowered = value.toLowerCase();
+  let start = 0;
+  let inExpires = false;
+  for (let index = 0;index < value.length; index += 1) {
+    if (lowered.startsWith("expires=", index)) {
+      inExpires = true;
+    }
+    const character = value[index];
+    if (character === ";") {
+      inExpires = false;
+    }
+    if (character !== "," || inExpires) {
+      continue;
+    }
+    const next = value.slice(index + 1);
+    if (!/^\s*[\w!#$%&'*+\-.^`|~]+=/u.test(next)) {
+      continue;
+    }
+    cookies.push(value.slice(start, index).trim());
+    start = index + 1;
+  }
+  const finalCookie = value.slice(start).trim();
+  if (finalCookie.length > 0) {
+    cookies.push(finalCookie);
+  }
+  return cookies;
+};
+function createCookieStoreFetch(cookieStore, fetchImpl = globalThis.fetch) {
+  return async (input, init) => {
+    const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : undefined));
+    if (!cookieStore.isEmpty() && !headers.has("cookie")) {
+      headers.set("cookie", cookieStore.header());
+    }
+    const response = await fetchImpl(input, { ...init, headers });
+    if (response.status < 500) {
+      cookieStore.storeSetCookieHeaders(getSetCookieHeaders(response.headers));
+    }
+    return response;
+  };
+}
+// package.json
+var package_default = {
+  name: "@settlemint/dalp-sdk",
+  version: "3.1.18-main.33796544973",
+  private: false,
+  description: "Fully typed SDK for the DALP tokenization platform API",
+  homepage: "https://settlemint.com",
+  bugs: {
+    email: "support@settlemint.com"
+  },
+  license: "SEE LICENSE IN LICENSE",
+  author: {
+    name: "SettleMint",
+    email: "support@settlemint.com",
+    url: "https://settlemint.com"
+  },
+  files: [
+    "dist",
+    "README.md",
+    "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",
+      default: "./dist/index.js"
+    },
+    "./types": {
+      types: "./dist/types.d.ts",
+      import: "./dist/types.js",
+      default: "./dist/types.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: "bun scripts/build.ts && bun scripts/check-dts-portability.ts && bun scripts/ensure-dist.ts --check",
+    "ensure-dist": "bun scripts/ensure-dist.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 publish --tolerate-republish --ignore-scripts --tag ${TAG:-latest} --access public",
+    prepack: "cp ../../LICENSE .",
+    test: "bun test --timeout 30000 tests/unit",
+    "test:coverage": "bun test --timeout 30000 --coverage --coverage-reporter=lcov --coverage-reporter=text tests/unit",
+    lint: "oxfmt --check .",
+    typecheck: "oxlint --deny-warnings . && tsc --noEmit -p scripts/tsconfig.json",
+    "check:zero-effect": "bun scripts/check-zero-effect.ts",
+    "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.7.2",
+    "@better-auth/passkey": "1.7.2",
+    "better-auth": "1.7.2",
+    "better-call": "1.4.0",
+    dnum: "2.17.0",
+    standardwebhooks: "1.1.1",
+    viem: "2.56.1"
+  },
+  devDependencies: {
+    "@arethetypeswrong/cli": "0.18.5",
+    "@core/schema": "workspace:*",
+    "@tanstack/react-query": "5.102.8",
+    "@tools/typescript-config": "workspace:*",
+    "@types/bun": "catalog:toolchain",
+    effect: "catalog:effect",
+    publint: "0.3.24",
+    typescript: "7.0.2",
+    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"
+  }
+};
+
+// src/version.ts
+var SDK_VERSION = package_default.version;
+var SDK_USER_AGENT = `DALP SDK v${SDK_VERSION}`;
+
+export { makeCookieStore, createCookieStoreFetch, SDK_VERSION, SDK_USER_AGENT };

package/dist/chunk-x0z79vz6.js

@@ -0,0 +1,33 @@
+import {
+  buildProxy,
+  findRoute
+} from "./chunk-f4t1bm86.js";
+import {
+  createFetchExecutor,
+  createTanstackFactories,
+  createTransport,
+  sendRequest,
+  streamRequest
+} from "./chunk-def7rqy6.js";
+import {
+  data
+} from "./chunk-18qmk0m7.js";
+
+// src/proxy/client.ts
+function createDalpClient(options) {
+  const transport = createTransport(options);
+  const api = buildProxy(data, createFetchExecutor(transport), createTanstackFactories(transport));
+  return {
+    api,
+    conditionalRequests: transport.conditionalRequests,
+    execute: async (routeId, input, callOptions) => {
+      const route = findRoute(data, routeId);
+      if (route === undefined) {
+        throw new TypeError(`Unknown DALP route \`${routeId}\``);
+      }
+      const result = route.serializer === "sse" ? streamRequest(transport, route, input, callOptions) : await sendRequest(transport, route, input, callOptions);
+      return result;
+    }
+  };
+}
+export { createDalpClient };

package/dist/chunk-y0d2c7kp.js

@@ -0,0 +1,54 @@
+// src/errors/sdk-error.ts
+var DALP_SDK_ERROR_CODE = "DALP_SDK_ERROR";
+var DALP_SDK_ERROR_CATEGORY = "sdk.configuration";
+
+class DalpSdkError extends Error {
+  code;
+  category;
+  status;
+  retryable;
+  why;
+  fix;
+  details;
+  retryAfterSeconds;
+  constructor(options) {
+    super(options.message, { cause: options.cause });
+    this.name = "DalpSdkError";
+    this.code = options.code ?? DALP_SDK_ERROR_CODE;
+    this.category = options.category;
+    this.status = options.status;
+    this.retryable = options.retryable;
+    this.why = options.why;
+    this.fix = options.fix;
+    this.details = options.details;
+    this.retryAfterSeconds = options.retryAfterSeconds;
+  }
+  toJSON() {
+    return {
+      name: "DalpSdkError",
+      code: this.code,
+      category: this.category,
+      retryable: this.retryable,
+      message: this.message,
+      why: this.why,
+      fix: this.fix,
+      ...this.status === undefined ? {} : { status: this.status },
+      ...this.details === undefined ? {} : { details: this.details },
+      ...this.retryAfterSeconds === undefined ? {} : { retryAfterSeconds: this.retryAfterSeconds }
+    };
+  }
+}
+function createDalpSdkConfigurationError(input) {
+  return new DalpSdkError({
+    code: DALP_SDK_ERROR_CODE,
+    category: DALP_SDK_ERROR_CATEGORY,
+    status: 400,
+    retryable: false,
+    message: input.message,
+    why: input.why,
+    fix: input.fix,
+    cause: input.cause
+  });
+}
+
+export { DalpSdkError, createDalpSdkConfigurationError };

package/dist/client/conditional-request.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Conditional GET, as a fetch decorator.
+ *
+ * The policy is unchanged from the interceptor pair this replaces: hold the
+ * ETag and body of a successful GET, send `If-None-Match` on the next one, and
+ * serve the held body on a 304. Only the attachment point moved, from a
+ * generated client's interceptor list to the fetch the transport already wraps
+ * for compression and SSR.
+ */
+import type { DalpFetch } from "./ssr-fetch.ts";
+/** Handle a caller holds so it can clear the store on sign-out or org switch. */
+export interface ConditionalRequestStore {
+    readonly clear: () => void;
+}
+/**
+ * Wrap `fetch` with the If-None-Match / 304 rewrite pair for conditional GET.
+ *
+ * Server ETags must be strong content digests computed after authorization
+ * inside the requester's partition. The dapi response cache guarantees this:
+ * `encodeResponseCacheEntry` sets `etag` to the SHA-256 of the serialized
+ * body after the request-context middleware has authenticated the session.
+ * Version-stamp ETags (generation counters, watermarks, table versions) are
+ * forbidden for conditional-request adopters: a stamp can collide across
+ * tenants or lag a body change and would let this store serve another
+ * partition's bytes as a 200.
+ */
+export declare function withConditionalRequests(base: DalpFetch): {
+    fetch: DalpFetch;
+    store: ConditionalRequestStore;
+};

package/dist/client/factory.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The client factory.
+ *
+ * The transport policy this used to assemble around the generated client now
+ * lives in `../proxy/transport.ts`, which both interpreters share. This module
+ * stays as the published entry point's seam so a consumer's import path did not
+ * move with the internals.
+ *
+ * @module
+ */
+export { createDalpClient, type DalpClient } from "../proxy/client.ts";
+export { createDalpContextHeaders } from "../proxy/transport.ts";
+export type { CreateDalpClientOptions, DalpClientContext, DalpSsrOptions, Transport } from "../proxy/transport.ts";
+export type { DalpFetch } from "./ssr-fetch.ts";

package/dist/client/query-serializer.d.ts

@@ -0,0 +1,2 @@
+/** Serialize generated SDK query objects with recursive OpenAPI deepObject keys. */
+export declare function serializeDalpQuery(query: unknown): string;