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

package/dist/chunk-d0295j58.js

@@ -0,0 +1,33 @@
+import {
+  data
+} from "./chunk-09prmw53.js";
+import {
+  createTransport,
+  streamRequest,
+  sendRequest,
+  createFetchExecutor,
+  createTanstackFactories
+} from "./chunk-shp8v4ws.js";
+import {
+  buildProxy,
+  findRoute
+} from "./chunk-rb8k4w3q.js";
+
+// src/proxy/client.ts
+function createDalpClient2(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 { createDalpClient2 };

package/dist/chunk-j4sxrfzz.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 DalpSdkError2 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 createDalpSdkConfigurationError2(input) {
+  return new DalpSdkError2({
+    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 { DalpSdkError2, createDalpSdkConfigurationError2 };

package/dist/chunk-qvtjb3dz.js

@@ -0,0 +1,102 @@
+// src/verify-webhook.ts
+import { Webhook as StandardWebhook } from "standardwebhooks";
+var DEFAULT_TIMESTAMP_TOLERANCE_SECONDS = 5 * 60;
+function toStandardWebhookSecret2(secret) {
+  return secret.replace(/^dalp_whsk_/u, "");
+}
+async function verifyWebhook2(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(toStandardWebhookSecret2(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 { toStandardWebhookSecret2, verifyWebhook2 };

package/dist/chunk-rb8k4w3q.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 };