@settlemint/dalp-cli 3.1.19-main.36458349696 → 3.1.19-main.36472209091

package/dist/dalp.js

@@ -41068,6 +41068,7 @@ var SDK_LOCAL_ERROR_CODES = new Set([
   "sdk.transport.UNVERIFIED_ERROR_CODE",
   "sdk.response.MALFORMED_SUCCESS",
   "sdk.stream.FAILED",
+  "sdk.stream.UNREADABLE_BODY",
   "sdk.scalar.BIG_DECIMAL_INVALID",
   "sdk.scalar.EVM_ADDRESS_INVALID",
   "sdk.scalar.ORGANIZATION_ID_INVALID",
@@ -41162,6 +41163,32 @@ function normalizeDalpBaseUrl(url) {
   return `${parsed.origin}${parsed.pathname.replace(/\/+$/, "")}`;
 }
 
+// ../sdk/src/runtime.ts
+var REACT_NATIVE_NAVIGATOR_PRODUCT = "ReactNative";
+function detectDalpRuntime() {
+  if (Reflect.get(globalThis, "navigator") !== undefined && Reflect.get(navigator, "product") === REACT_NATIVE_NAVIGATOR_PRODUCT) {
+    return "react-native";
+  }
+  return globalThis.window === undefined ? "server" : "browser";
+}
+function runtimeCredentials(runtime) {
+  return runtime === "browser" ? "include" : "omit";
+}
+var WHATWG_FETCH_POLYFILL_FLAG = "polyfill";
+function isBufferingFetch(fetchImpl) {
+  return typeof fetchImpl === "function" && Reflect.get(fetchImpl, WHATWG_FETCH_POLYFILL_FLAG) === true;
+}
+function refuseBundledApiKey(runtime) {
+  if (runtime === "server") {
+    return;
+  }
+  throw createDalpSdkConfigurationError({
+    message: `DALP SDK: API keys are server/CLI-only credentials and cannot configure a ${runtime} client.`,
+    why: "An API key placed in a browser or app bundle ships the credential to every visitor or device.",
+    fix: "Keep the API key on the server or CLI process; browser and app clients authenticate with the session cookie."
+  });
+}
+
 // ../sdk/src/client/query-serializer.ts
 function appendQueryValue(search, path, value) {
   if (value === undefined || value === null) {
@@ -41489,10 +41516,10 @@ async function captureSuccessfulGet(store, key, response) {
     store.delete(key);
     return response;
   }
-  const body = new Uint8Array(await response.arrayBuffer());
+  const body = await response.blob();
   const headers = new Headers(response.headers);
   headers.set("etag", etag);
-  if (body.byteLength <= CONDITIONAL_RESPONSE_MAX_BODY_BYTES) {
+  if (body.size <= CONDITIONAL_RESPONSE_MAX_BODY_BYTES) {
     remember(store, key, { body, etag, headers });
   }
   return new Response(body, {
@@ -41540,7 +41567,7 @@ function withConditionalRequests(base) {
       const retried = await base(requestWithoutIfNoneMatch(sent));
       return retried.status === 304 ? retried : captureSuccessfulGet(state.store, key, retried);
     }
-    return new Response(new Uint8Array(entry.body), { status: 200, statusText: "OK", headers: entry.headers });
+    return new Response(entry.body, { status: 200, statusText: "OK", headers: entry.headers });
   };
   return {
     fetch: decorated,
@@ -41666,9 +41693,9 @@ function preferDirective(timeoutMs) {
 }
 function createTransport(options) {
   const baseUrl = normalizeDalpBaseUrl(String(options.baseUrl));
-  const runtime = options.runtime ?? (globalThis.window === undefined ? "server" : "browser");
+  const runtime = options.runtime ?? detectDalpRuntime();
   const baseFetch = options.fetch ?? globalThis.fetch;
-  const transportFetch = runtime === "browser" ? baseFetch : withRequestBodyCompression(baseFetch);
+  const transportFetch = runtime === "server" ? withRequestBodyCompression(baseFetch) : baseFetch;
   const { apiKey: apiKeyOption } = options;
   let apiKey;
   if (apiKeyOption === undefined) {
@@ -41678,12 +41705,8 @@ function createTransport(options) {
   } else {
     apiKey = secret(apiKeyOption.trim());
   }
-  if (runtime === "browser" && apiKey !== undefined) {
-    throw createDalpSdkConfigurationError({
-      message: "DALP SDK: API keys are server/CLI-only credentials and cannot configure a browser client.",
-      why: "An API key placed in a browser client ships the credential to every visitor's bundle.",
-      fix: "Keep the API key on the server or CLI process; browser clients authenticate with the session cookie."
-    });
+  if (apiKey !== undefined) {
+    refuseBundledApiKey(runtime);
   }
   const sessionFetch = options.ssr === undefined ? transportFetch : createSsrFetch({
     allowedOrigins: options.ssr.allowedOrigins,
@@ -41696,14 +41719,18 @@ function createTransport(options) {
   if (options.authSurface !== undefined) {
     contextHeaders.set(DALP_AUTH_SURFACE_HEADER, options.authSurface);
   }
+  if (runtime === "react-native") {
+    contextHeaders.set("Origin", new URL(baseUrl).origin);
+  }
   return {
     baseUrl,
     fetch: conditional.fetch,
     conditionalRequests: conditional.store,
-    credentials: runtime === "browser" ? "include" : "omit",
+    credentials: runtimeCredentials(runtime),
     apiKey,
     contextHeaders,
-    settlementTimeoutMs: options.settlementTimeoutMs
+    settlementTimeoutMs: options.settlementTimeoutMs,
+    streamsResponseBody: !isBufferingFetch(baseFetch)
   };
 }
 function callHeaders(transport, options) {
@@ -42302,6 +42329,21 @@ async function loadResponseDecoder() {
 // ../sdk/src/proxy/sse.ts
 var RESERVED_STREAM_FAILURE_EVENT = "effect/httpapi/stream/failure";
 var STREAM_FAILED_ERROR_CODE = "sdk.stream.FAILED";
+var STREAM_UNREADABLE_BODY_ERROR_CODE = "sdk.stream.UNREADABLE_BODY";
+function isReadableBody(body) {
+  return typeof body === "object" && body !== null && typeof Reflect.get(body, "getReader") === "function";
+}
+function unreadableBodyError(routeId) {
+  return makeDalpApiError(new DalpSdkError({
+    code: STREAM_UNREADABLE_BODY_ERROR_CODE,
+    routeId,
+    category: "sdk.configuration",
+    retryable: false,
+    message: "The fetch this client uses cannot stream a response body.",
+    why: "React Native's built-in fetch resolves only after the whole response has arrived and exposes no `response.body`, so a stream never yields a frame.",
+    fix: 'Pass a streaming fetch as `fetch`; on React Native that is `fetch` from "expo/fetch", wrapped with the cookie store.'
+  }));
+}
 function parseFrame(raw) {
   try {
     return JSON.parse(raw.data);
@@ -42382,6 +42424,9 @@ async function* decodeEventStream(body, decodeFrame, routeId) {
   }
 }
 async function* openEventStream(transport, route, routeId, input, options, signal, closed) {
+  if (!transport.streamsResponseBody) {
+    throw unreadableBodyError(routeId);
+  }
   const prepared = prepareRequest(transport, route, input, options);
   prepared.headers.set("Accept", "text/event-stream");
   const response = await transport.fetch(prepared.url, {
@@ -42394,13 +42439,16 @@ async function* openEventStream(transport, route, routeId, input, options, signa
   if (!response.ok) {
     await raiseResponseError(response, routeId);
   }
-  if (response.body === null) {
+  const { body, status } = response;
+  if (body === null) {
     return;
   }
+  if (!isReadableBody(body)) {
+    throw unreadableBodyError(routeId);
+  }
   const decoder = await loadResponseDecoder();
-  const { status } = response;
   try {
-    yield* decodeEventStream(response.body, (frame) => decoder.decode(routeId, status, frame), routeId);
+    yield* decodeEventStream(body, (frame) => decoder.decode(routeId, status, frame), routeId);
   } catch (error) {
     if (!closed.byConsumer) {
       throw error;
@@ -42477,14 +42525,644 @@ var canonicalText = (value, omitted = null) => {
   return `{${presentEntries(Object.entries(value), omitted).map(([key, field]) => `${JSON.stringify(key)}:${canonicalText(field)}`).join(",")}}`;
 };
 var stepUpPayloadText = (body) => canonicalText(body, PROOF_FIELD);
+// ../node_modules/.bun/viem@2.56.8+17ce2293f28dc2b8/node_modules/viem/_esm/errors/version.js
+var version3 = "2.56.8";
+
+// ../node_modules/.bun/viem@2.56.8+17ce2293f28dc2b8/node_modules/viem/_esm/errors/base.js
+var errorConfig = {
+  getDocsUrl: ({ docsBaseUrl, docsPath = "", docsSlug }) => docsPath ? `${docsBaseUrl ?? "https://viem.sh"}${docsPath}${docsSlug ? `#${docsSlug}` : ""}` : undefined,
+  version: `viem@${version3}`
+};
+class BaseError2 extends Error {
+  constructor(shortMessage, args = {}) {
+    const details = (() => {
+      if (args.cause instanceof BaseError2)
+        return args.cause.details;
+      if (args.cause?.message)
+        return args.cause.message;
+      return args.details;
+    })();
+    const docsPath = (() => {
+      if (args.cause instanceof BaseError2)
+        return args.cause.docsPath || args.docsPath;
+      return args.docsPath;
+    })();
+    const docsUrl = errorConfig.getDocsUrl?.({ ...args, docsPath });
+    const message = [
+      shortMessage || "An error occurred.",
+      "",
+      ...args.metaMessages ? [...args.metaMessages, ""] : [],
+      ...docsUrl ? [`Docs: ${docsUrl}`] : [],
+      ...details ? [`Details: ${details}`] : [],
+      ...errorConfig.version ? [`Version: ${errorConfig.version}`] : []
+    ].join(`
+`);
+    super(message, args.cause ? { cause: args.cause } : undefined);
+    Object.defineProperty(this, "details", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: undefined
+    });
+    Object.defineProperty(this, "docsPath", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: undefined
+    });
+    Object.defineProperty(this, "metaMessages", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: undefined
+    });
+    Object.defineProperty(this, "shortMessage", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: undefined
+    });
+    Object.defineProperty(this, "version", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: undefined
+    });
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "BaseError"
+    });
+    this.details = details;
+    this.docsPath = docsPath;
+    this.metaMessages = args.metaMessages;
+    this.name = args.name ?? this.name;
+    this.shortMessage = shortMessage;
+    this.version = version3;
+  }
+  walk(fn) {
+    return walk3(this, fn);
+  }
+}
+function walk3(err, fn) {
+  if (fn?.(err))
+    return err;
+  if (err && typeof err === "object" && "cause" in err && err.cause !== undefined)
+    return walk3(err.cause, fn);
+  return fn ? null : err;
+}
+
+// ../node_modules/.bun/viem@2.56.8+17ce2293f28dc2b8/node_modules/viem/_esm/utils/data/isHex.js
+function isHex(value, { strict = true } = {}) {
+  if (!value)
+    return false;
+  if (typeof value !== "string")
+    return false;
+  return strict ? /^0x[0-9a-fA-F]*$/.test(value) : value.startsWith("0x");
+}
+
+// ../node_modules/.bun/viem@2.56.8+17ce2293f28dc2b8/node_modules/viem/_esm/errors/data.js
+class SizeExceedsPaddingSizeError extends BaseError2 {
+  constructor({ size, targetSize, type }) {
+    super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
+  }
+}
+
+// ../node_modules/.bun/viem@2.56.8+17ce2293f28dc2b8/node_modules/viem/_esm/utils/data/pad.js
+function pad(hexOrBytes, { dir, size = 32 } = {}) {
+  if (typeof hexOrBytes === "string")
+    return padHex(hexOrBytes, { dir, size });
+  return padBytes(hexOrBytes, { dir, size });
+}
+function padHex(hex_, { dir, size = 32 } = {}) {
+  if (size === null)
+    return hex_;
+  const hex = hex_.replace("0x", "");
+  if (hex.length > size * 2)
+    throw new SizeExceedsPaddingSizeError({
+      size: Math.ceil(hex.length / 2),
+      targetSize: size,
+      type: "hex"
+    });
+  return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size * 2, "0")}`;
+}
+function padBytes(bytes, { dir, size = 32 } = {}) {
+  if (size === null)
+    return bytes;
+  if (bytes.length > size)
+    throw new SizeExceedsPaddingSizeError({
+      size: bytes.length,
+      targetSize: size,
+      type: "bytes"
+    });
+  const paddedBytes = new Uint8Array(size);
+  for (let i = 0;i < size; i++) {
+    const padEnd = dir === "right";
+    paddedBytes[padEnd ? i : size - i - 1] = bytes[padEnd ? i : bytes.length - i - 1];
+  }
+  return paddedBytes;
+}
+
+// ../node_modules/.bun/viem@2.56.8+17ce2293f28dc2b8/node_modules/viem/_esm/errors/encoding.js
+class IntegerOutOfRangeError extends BaseError2 {
+  constructor({ max, min, signed, size, value }) {
+    super(`Number "${value}" is not in safe ${size ? `${size * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
+  }
+}
+class SizeOverflowError extends BaseError2 {
+  constructor({ givenSize, maxSize }) {
+    super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: "SizeOverflowError" });
+  }
+}
+
+// ../node_modules/.bun/viem@2.56.8+17ce2293f28dc2b8/node_modules/viem/_esm/utils/data/size.js
+function size(value) {
+  if (isHex(value, { strict: false }))
+    return Math.ceil((value.length - 2) / 2);
+  return value.length;
+}
+
+// ../node_modules/.bun/viem@2.56.8+17ce2293f28dc2b8/node_modules/viem/_esm/utils/encoding/fromHex.js
+function assertSize(hexOrBytes, { size: size2 }) {
+  if (size(hexOrBytes) > size2)
+    throw new SizeOverflowError({
+      givenSize: size(hexOrBytes),
+      maxSize: size2
+    });
+}
+
+// ../node_modules/.bun/viem@2.56.8+17ce2293f28dc2b8/node_modules/viem/_esm/utils/encoding/toHex.js
+var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
+function toHex(value, opts = {}) {
+  if (typeof value === "number" || typeof value === "bigint")
+    return numberToHex(value, opts);
+  if (typeof value === "string") {
+    return stringToHex(value, opts);
+  }
+  if (typeof value === "boolean")
+    return boolToHex(value, opts);
+  return bytesToHex(value, opts);
+}
+function boolToHex(value, opts = {}) {
+  const hex = `0x${Number(value)}`;
+  if (typeof opts.size === "number") {
+    assertSize(hex, { size: opts.size });
+    return pad(hex, { size: opts.size });
+  }
+  return hex;
+}
+function bytesToHex(value, opts = {}) {
+  let string = "";
+  for (let i = 0;i < value.length; i++) {
+    string += hexes[value[i]];
+  }
+  const hex = `0x${string}`;
+  if (typeof opts.size === "number") {
+    assertSize(hex, { size: opts.size });
+    return pad(hex, { dir: "right", size: opts.size });
+  }
+  return hex;
+}
+function numberToHex(value_, opts = {}) {
+  const { signed, size } = opts;
+  const value = BigInt(value_);
+  let maxValue;
+  if (size) {
+    if (signed)
+      maxValue = (1n << BigInt(size) * 8n - 1n) - 1n;
+    else
+      maxValue = 2n ** (BigInt(size) * 8n) - 1n;
+  } else if (typeof value_ === "number") {
+    maxValue = BigInt(Number.MAX_SAFE_INTEGER);
+  }
+  const minValue = typeof maxValue === "bigint" && signed ? -maxValue - 1n : 0;
+  if (maxValue && value > maxValue || value < minValue) {
+    const suffix = typeof value_ === "bigint" ? "n" : "";
+    throw new IntegerOutOfRangeError({
+      max: maxValue ? `${maxValue}${suffix}` : undefined,
+      min: `${minValue}${suffix}`,
+      signed,
+      size,
+      value: `${value_}${suffix}`
+    });
+  }
+  const hex = `0x${(signed && value < 0 ? (1n << BigInt(size * 8)) + BigInt(value) : value).toString(16)}`;
+  if (size)
+    return pad(hex, { size });
+  return hex;
+}
+var encoder = /* @__PURE__ */ new TextEncoder;
+function stringToHex(value_, opts = {}) {
+  const value = encoder.encode(value_);
+  return bytesToHex(value, opts);
+}
 
+// ../node_modules/.bun/viem@2.56.8+17ce2293f28dc2b8/node_modules/viem/_esm/utils/encoding/toBytes.js
+var encoder2 = /* @__PURE__ */ new TextEncoder;
+function toBytes(value, opts = {}) {
+  if (typeof value === "number" || typeof value === "bigint")
+    return numberToBytes(value, opts);
+  if (typeof value === "boolean")
+    return boolToBytes(value, opts);
+  if (isHex(value))
+    return hexToBytes(value, opts);
+  return stringToBytes(value, opts);
+}
+function boolToBytes(value, opts = {}) {
+  const bytes = new Uint8Array(1);
+  bytes[0] = Number(value);
+  if (typeof opts.size === "number") {
+    assertSize(bytes, { size: opts.size });
+    return pad(bytes, { size: opts.size });
+  }
+  return bytes;
+}
+var charCodeMap = {
+  zero: 48,
+  nine: 57,
+  A: 65,
+  F: 70,
+  a: 97,
+  f: 102
+};
+function charCodeToBase16(char) {
+  if (char >= charCodeMap.zero && char <= charCodeMap.nine)
+    return char - charCodeMap.zero;
+  if (char >= charCodeMap.A && char <= charCodeMap.F)
+    return char - (charCodeMap.A - 10);
+  if (char >= charCodeMap.a && char <= charCodeMap.f)
+    return char - (charCodeMap.a - 10);
+  return;
+}
+function hexToBytes(hex_, opts = {}) {
+  let hex = hex_;
+  if (opts.size) {
+    assertSize(hex, { size: opts.size });
+    hex = pad(hex, { dir: "right", size: opts.size });
+  }
+  let hexString = hex.slice(2);
+  if (hexString.length % 2)
+    hexString = `0${hexString}`;
+  const length = hexString.length / 2;
+  const bytes = new Uint8Array(length);
+  for (let index = 0, j = 0;index < length; index++) {
+    const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
+    const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
+    if (nibbleLeft === undefined || nibbleRight === undefined) {
+      throw new BaseError2(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
+    }
+    bytes[index] = nibbleLeft * 16 + nibbleRight;
+  }
+  return bytes;
+}
+function numberToBytes(value, opts) {
+  const hex = numberToHex(value, opts);
+  return hexToBytes(hex);
+}
+function stringToBytes(value, opts = {}) {
+  const bytes = encoder2.encode(value);
+  if (typeof opts.size === "number") {
+    assertSize(bytes, { size: opts.size });
+    return pad(bytes, { dir: "right", size: opts.size });
+  }
+  return bytes;
+}
+// ../node_modules/.bun/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/utils.js
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function abytes(b, ...lengths) {
+  if (!isBytes(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error("digestInto() expects output buffer of length at least " + min);
+  }
+}
+function clean(...arrays) {
+  for (let i = 0;i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
+}
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes2(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  abytes(data);
+  return data;
+}
+class Hash {
+}
+function createHasher(hashCons) {
+  const hashC = (msg) => hashCons().update(toBytes2(msg)).digest();
+  const tmp = hashCons();
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = () => hashCons();
+  return hashC;
+}
+
+// ../node_modules/.bun/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/_md.js
+function setBigUint64(view, byteOffset, value, isLE) {
+  if (typeof view.setBigUint64 === "function")
+    return view.setBigUint64(byteOffset, value, isLE);
+  const _32n = BigInt(32);
+  const _u32_max = BigInt(4294967295);
+  const wh = Number(value >> _32n & _u32_max);
+  const wl = Number(value & _u32_max);
+  const h = isLE ? 4 : 0;
+  const l = isLE ? 0 : 4;
+  view.setUint32(byteOffset + h, wh, isLE);
+  view.setUint32(byteOffset + l, wl, isLE);
+}
+function Chi(a, b, c) {
+  return a & b ^ ~a & c;
+}
+function Maj(a, b, c) {
+  return a & b ^ a & c ^ b & c;
+}
+
+class HashMD extends Hash {
+  constructor(blockLen, outputLen, padOffset, isLE) {
+    super();
+    this.finished = false;
+    this.length = 0;
+    this.pos = 0;
+    this.destroyed = false;
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+  }
+  update(data) {
+    aexists(this);
+    data = toBytes2(data);
+    abytes(data);
+    const { view, buffer, blockLen } = this;
+    const len = data.length;
+    for (let pos = 0;pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView(data);
+        for (;blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+      }
+    }
+    this.length += data.length;
+    this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    clean(this.buffer.subarray(pos));
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      pos = 0;
+    }
+    for (let i = pos;i < blockLen; i++)
+      buffer[i] = 0;
+    setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
+    this.process(view, 0);
+    const oview = createView(out);
+    const len = this.outputLen;
+    if (len % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const outLen = len / 4;
+    const state = this.get();
+    if (outLen > state.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let i = 0;i < outLen; i++)
+      oview.setUint32(4 * i, state[i], isLE);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    to || (to = new this.constructor);
+    to.set(...this.get());
+    const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    if (length % blockLen)
+      to.buffer.set(buffer);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+}
+var SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+
+// ../node_modules/.bun/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/sha2.js
+var SHA256_K = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+
+class SHA256 extends HashMD {
+  constructor(outputLen = 32) {
+    super(64, outputLen, 8, false);
+    this.A = SHA256_IV[0] | 0;
+    this.B = SHA256_IV[1] | 0;
+    this.C = SHA256_IV[2] | 0;
+    this.D = SHA256_IV[3] | 0;
+    this.E = SHA256_IV[4] | 0;
+    this.F = SHA256_IV[5] | 0;
+    this.G = SHA256_IV[6] | 0;
+    this.H = SHA256_IV[7] | 0;
+  }
+  get() {
+    const { A, B, C, D, E, F, G, H } = this;
+    return [A, B, C, D, E, F, G, H];
+  }
+  set(A, B, C, D, E, F, G, H) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+    this.E = E | 0;
+    this.F = F | 0;
+    this.G = G | 0;
+    this.H = H | 0;
+  }
+  process(view, offset) {
+    for (let i = 0;i < 16; i++, offset += 4)
+      SHA256_W[i] = view.getUint32(offset, false);
+    for (let i = 16;i < 64; i++) {
+      const W15 = SHA256_W[i - 15];
+      const W2 = SHA256_W[i - 2];
+      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+    }
+    let { A, B, C, D, E, F, G, H } = this;
+    for (let i = 0;i < 64; i++) {
+      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+      const T2 = sigma0 + Maj(A, B, C) | 0;
+      H = G;
+      G = F;
+      F = E;
+      E = D + T1 | 0;
+      D = C;
+      C = B;
+      B = A;
+      A = T1 + T2 | 0;
+    }
+    A = A + this.A | 0;
+    B = B + this.B | 0;
+    C = C + this.C | 0;
+    D = D + this.D | 0;
+    E = E + this.E | 0;
+    F = F + this.F | 0;
+    G = G + this.G | 0;
+    H = H + this.H | 0;
+    this.set(A, B, C, D, E, F, G, H);
+  }
+  roundClean() {
+    clean(SHA256_W);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    clean(this.buffer);
+  }
+}
+var sha256 = /* @__PURE__ */ createHasher(() => new SHA256);
+
+// ../node_modules/.bun/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/sha256.js
+var sha2562 = sha256;
+
+// ../node_modules/.bun/viem@2.56.8+17ce2293f28dc2b8/node_modules/viem/_esm/utils/hash/sha256.js
+function sha2563(value, to_) {
+  const to = to_ || "hex";
+  const bytes = sha2562(isHex(value, { strict: false }) ? toBytes(value) : value);
+  if (to === "bytes")
+    return bytes;
+  return toHex(bytes);
+}
 // ../sdk/src/client/step-up-challenge.ts
 var STEP_UP_CHALLENGE_HEADER = "X-Step-Up-Challenge";
 var WALLET_VERIFICATION_HEADER = "X-Wallet-Verification";
 var STEP_UP_CHALLENGE_PATH = "/api/v2/step-up-challenges";
 var PROOF_FIELD2 = "walletVerification";
-var HEX_RADIX = 16;
-var HEX_BYTE_WIDTH = 2;
+var HEX_PREFIX = "0x";
 function carriesWalletProof(body) {
   if (body === null || typeof body !== "object" || Array.isArray(body)) {
     return false;
@@ -42493,8 +43171,7 @@ function carriesWalletProof(body) {
   return proof !== null && proof !== undefined;
 }
 async function stepUpChallengeRequest(operation, target, body) {
-  const digest = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(stepUpPayloadText(body)));
-  const payloadDigest = Array.from(new Uint8Array(digest), (byte) => byte.toString(HEX_RADIX).padStart(HEX_BYTE_WIDTH, "0")).join("");
+  const payloadDigest = sha2563(stringToBytes(stepUpPayloadText(body))).slice(HEX_PREFIX.length);
   return { operation, target, payloadDigest };
 }
 
@@ -42625,7 +43302,7 @@ var WEBHOOK_MANIFEST_VERSION = Webhook.MANIFEST_VERSION;
 // ../sdk/package.json
 var package_default = {
   name: "@settlemint/dalp-sdk",
-  version: "3.1.19-main.36458349696",
+  version: "3.1.19-main.36472209091",
   private: false,
   description: "Fully typed SDK for the DALP tokenization platform API",
   homepage: "https://settlemint.com",
@@ -42752,10 +43429,12 @@ var package_default = {
     "@tools/typescript-config": "workspace:*",
     "@tools/vitest-config": "workspace:*",
     "@types/bun": "1.4.2",
+    "abort-controller": "3.0.0",
     effect: "4.0.0-rc.117",
     publint: "0.3.24",
     typescript: "7.0.2",
     vitest: "5.0.1",
+    "whatwg-fetch": "3.6.20",
     zod: "4.6.5"
   },
   peerDependencies: {
@@ -96792,7 +97471,7 @@ async function runCommand(context, operation, errorContext = UNKNOWN_COMMAND_ERR
 // package.json
 var package_default2 = {
   name: "@settlemint/dalp-cli",
-  version: "3.1.19-main.36458349696",
+  version: "3.1.19-main.36472209091",
   private: false,
   description: "CLI for the Digital Asset Lifecycle Platform \u2014 manage tokens, identities, compliance, and more from the command line.",
   homepage: "https://settlemint.com",
@@ -98155,4 +98834,4 @@ if (false) {}
 // src/bin.ts
 await cli.serve();
 
-//# debugId=99BDF7D2D329261364756E2164756E21
+//# debugId=1DCEF7CADEDEEAFF64756E2164756E21