@otskit/client 0.2.0 → 0.4.0

package/dist/index.cjs

@@ -29,7 +29,7 @@ __export(index_exports, {
   DEFAULT_CALENDARS: () => DEFAULT_CALENDARS,
   DEFAULT_CALENDAR_WHITELIST: () => DEFAULT_CALENDAR_WHITELIST,
   DEFAULT_RESILIENCE: () => DEFAULT_RESILIENCE,
-  DetachedTimestampFile: () => DetachedTimestampFile,
+  DetachedTimestampFile: () => import_core5.DetachedTimestampFile,
   EsploraClient: () => EsploraClient,
   EsploraResponseError: () => EsploraResponseError,
   MAX_CALENDAR_RESPONSE_SIZE: () => MAX_CALENDAR_RESPONSE_SIZE,
@@ -39,25 +39,25 @@ __export(index_exports, {
   OpenTimestampsClientError: () => OpenTimestampsClientError,
   PUBLIC_ESPLORA_URL: () => PUBLIC_ESPLORA_URL,
   ResilientNetworkLayer: () => ResilientNetworkLayer,
+  SizeLimitExceededError: () => SizeLimitExceededError,
   StampError: () => StampError,
-  Timestamp: () => Timestamp,
+  Timestamp: () => import_core5.Timestamp,
   UpgradeError: () => UpgradeError,
   UrlWhitelist: () => UrlWhitelist,
   ValidationError: () => ValidationError,
+  assertSafeCalendarUrl: () => assertSafeCalendarUrl,
   hashBuffer: () => hashBuffer,
   hashFile: () => hashFile,
-  verifyAgainstBlockheader: () => verifyAgainstBlockheader,
+  isVerified: () => isVerified,
+  verifyAgainstBlockheader: () => import_core6.verifyAgainstBlockheader,
   verifyTimestampAttestation: () => verifyTimestampAttestation
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/types.ts
-var DEFAULT_CALENDARS = [
-  "https://alice.btc.calendar.opentimestamps.org",
-  "https://bob.btc.calendar.opentimestamps.org",
-  "https://finney.calendar.eternitywall.com",
-  "https://btc.calendar.catallaxy.com"
-];
+var import_core = require("@otskit/core");
+var isVerified = (r) => r.status === "verified";
+var DEFAULT_CALENDARS = [...import_core.DEFAULT_CALENDAR_URLS];
 var DEFAULT_RESILIENCE = {
   totalTimeoutMs: 3e4,
   connectTimeoutMs: 5e3,
@@ -121,6 +121,18 @@ var CalendarResponseTooLargeError = class extends NetworkError {
 };
 var EsploraResponseError = class extends NetworkError {
 };
+var SizeLimitExceededError = class extends NetworkError {
+  maxBytes;
+  actualBytes;
+  constructor(maxBytes, actualBytes, options) {
+    super(
+      actualBytes === void 0 ? `Response size exceeds limit of ${maxBytes} bytes` : `Response size ${actualBytes} bytes exceeds limit of ${maxBytes} bytes`,
+      options
+    );
+    this.maxBytes = maxBytes;
+    this.actualBytes = actualBytes;
+  }
+};
 
 // src/network/circuit-breaker.ts
 var CircuitState = /* @__PURE__ */ ((CircuitState2) => {
@@ -309,33 +321,62 @@ async function withRetry(fn, options, logger, signal) {
 }
 
 // src/adapters/fetch-adapter.ts
-async function executeRequest(request) {
+function getDeclaredContentLength(response) {
+  const value = response.headers.get("content-length");
+  if (value === null || !/^\d+$/.test(value)) return void 0;
+  const n = Number(value);
+  return Number.isSafeInteger(n) ? n : void 0;
+}
+async function readStreamLimited(body, maxBytes, status) {
+  const reader = body.getReader();
+  const buffer = new Uint8Array(maxBytes);
+  let received = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) return buffer.subarray(0, received);
+      const next = received + value.byteLength;
+      if (next > maxBytes) {
+        await reader.cancel();
+        throw new SizeLimitExceededError(maxBytes, next, { status });
+      }
+      buffer.set(value, received);
+      received = next;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function readResponseBody(response, maxBytes) {
+  const contentLength = getDeclaredContentLength(response);
+  if (contentLength !== void 0 && contentLength > maxBytes) {
+    throw new SizeLimitExceededError(maxBytes, contentLength, { status: response.status });
+  }
+  if (response.body === null) {
+    const ab = await response.arrayBuffer();
+    if (ab.byteLength > maxBytes) {
+      throw new SizeLimitExceededError(maxBytes, ab.byteLength, { status: response.status });
+    }
+    return new Uint8Array(ab);
+  }
+  return readStreamLimited(response.body, maxBytes, response.status);
+}
+async function executeRequest(request, maxBytes) {
   try {
     const response = await globalThis.fetch(request.url, {
       method: request.method,
-      headers: {
-        "Content-Type": "application/octet-stream",
-        ...request.headers
-      },
+      headers: { "Content-Type": "application/octet-stream", ...request.headers },
       body: request.body,
       signal: request.signal
     });
-    const arrayBuffer = await response.arrayBuffer();
-    const data = new Uint8Array(arrayBuffer);
-    return {
-      ok: response.ok,
-      status: response.status,
-      statusText: response.statusText,
-      data
-    };
+    const data = await readResponseBody(response, maxBytes);
+    return { ok: response.ok, status: response.status, statusText: response.statusText, data };
   } catch (error) {
+    if (error instanceof SizeLimitExceededError) throw error;
+    if (error instanceof NetworkError) throw error;
     if (error instanceof Error) {
-      if (error.name === "AbortError") {
-        throw new NetworkError("Request aborted", { cause: error });
-      }
-      if (error.message.includes("timeout")) {
-        throw new NetworkError("Request timeout", { cause: error });
-      }
+      if (error.name === "AbortError") throw new NetworkError("Request aborted", { cause: error });
+      if (error.message.includes("timeout")) throw new NetworkError("Request timeout", { cause: error });
       throw new NetworkError(`Network request failed: ${error.message}`, { cause: error });
     }
     throw new NetworkError("Unknown network error");
@@ -343,23 +384,24 @@ async function executeRequest(request) {
 }
 function createTimeoutController(timeoutMs, parentSignal) {
   const controller = new AbortController();
-  const timeout = setTimeout(() => {
-    controller.abort(new Error("Timeout"));
-  }, timeoutMs);
+  const timeout = setTimeout(() => controller.abort(new Error("Timeout")), timeoutMs);
+  const onParentAbort = () => {
+    clearTimeout(timeout);
+    parentSignal?.removeEventListener("abort", onParentAbort);
+    controller.abort(parentSignal?.reason);
+  };
+  controller.signal.addEventListener("abort", () => {
+    clearTimeout(timeout);
+    parentSignal?.removeEventListener("abort", onParentAbort);
+  }, { once: true });
   if (parentSignal) {
     if (parentSignal.aborted) {
       clearTimeout(timeout);
       controller.abort(parentSignal.reason);
     } else {
-      parentSignal.addEventListener("abort", () => {
-        clearTimeout(timeout);
-        controller.abort(parentSignal.reason);
-      });
+      parentSignal.addEventListener("abort", onParentAbort, { once: true });
     }
   }
-  controller.signal.addEventListener("abort", () => {
-    clearTimeout(timeout);
-  });
   return controller;
 }
 
@@ -391,10 +433,10 @@ var ResilientNetworkLayer = class {
               totalController.signal
             );
             try {
-              const response = await executeRequest({
-                ...request,
-                signal: attemptController.signal
-              });
+              const response = await executeRequest(
+                { ...request, signal: attemptController.signal },
+                this.options.maxResponseBytes ?? 1e5
+              );
               const elapsed = Date.now() - startTime;
               this.logger?.debug(`Request to ${calendarUrl} succeeded in ${elapsed}ms`);
               if (!response.ok) {
@@ -413,8 +455,7 @@ var ResilientNetworkLayer = class {
               }
               return response;
             } finally {
-              attemptController.signal.removeEventListener("abort", () => {
-              });
+              attemptController.abort(new Error("Attempt complete"));
             }
           },
           this.options.retries,
@@ -427,8 +468,7 @@ var ResilientNetworkLayer = class {
       this.logger?.error(`Request to ${calendarUrl} failed after ${elapsed}ms`, error);
       throw error;
     } finally {
-      totalController.signal.removeEventListener("abort", () => {
-      });
+      totalController.abort(new Error("Request complete"));
     }
   }
   /** Get circuit breaker state for a calendar */
@@ -445,1453 +485,11 @@ var ResilientNetworkLayer = class {
   }
 };
 
-// ../otskit-core/dist/index.js
-var DeserializationError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = new.target.name;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var BadMagicError = class extends DeserializationError {
-};
-var TruncatedStreamError = class extends DeserializationError {
-};
-var OversizedDataError = class extends DeserializationError {
-};
-var VaruintOverflowError = class extends DeserializationError {
-};
-var TrailingGarbageError = class extends DeserializationError {
-};
-var UnknownOperationError = class extends DeserializationError {
-};
-var OpExecutionError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = new.target.name;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var MessageTooLongError = class extends OpExecutionError {
-};
-var ResultTooLongError = class extends OpExecutionError {
-};
-var InvalidUriError = class extends DeserializationError {
-};
-var VerificationError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = new.target.name;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var EmptyTimestampError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = new.target.name;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var MergeError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = new.target.name;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var EmptyMerkleTreeError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = new.target.name;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var UnsupportedVersionError = class extends DeserializationError {
-};
-var HEX_RE = /^[0-9a-fA-F]*$/;
-function hexToBytes(hex) {
-  if (hex.length % 2 !== 0) {
-    throw new Error(`hex string must have even length; got ${hex.length}`);
-  }
-  if (!HEX_RE.test(hex)) {
-    throw new Error("hex string contains non-hex characters");
-  }
-  const out = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < out.length; i++) {
-    out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-  }
-  return out;
-}
-var HEX_TABLE = Array.from({ length: 256 }, (_, b) => b.toString(16).padStart(2, "0"));
-function bytesToHex(bytes) {
-  let s = "";
-  for (let i = 0; i < bytes.length; i++) {
-    s += HEX_TABLE[bytes[i]];
-  }
-  return s;
-}
-var encoder = new TextEncoder();
-var decoder = new TextDecoder("utf-8", { fatal: true });
-function textToBytes(text) {
-  return encoder.encode(text);
-}
-function bytesEqual(a, b) {
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) return false;
-  }
-  return true;
-}
-function compareBytes(a, b) {
-  const min = Math.min(a.length, b.length);
-  for (let i = 0; i < min; i++) {
-    const d = a[i] - b[i];
-    if (d !== 0) return d;
-  }
-  return a.length - b.length;
-}
-var StreamDeserializationContext = class {
-  #buffer;
-  #counter = 0;
-  constructor(stream) {
-    if (!(stream instanceof Uint8Array)) {
-      throw new TypeError("StreamDeserializationContext expects a Uint8Array");
-    }
-    this.#buffer = stream;
-  }
-  get counter() {
-    return this.#counter;
-  }
-  /** Lee `length` bytes. Lanza si el stream no tiene suficientes. */
-  read(length) {
-    if (length < 0) throw new RangeError("read length must be >= 0");
-    if (this.#counter + length > this.#buffer.length) {
-      throw new TruncatedStreamError(
-        `attempted to read ${length} bytes at offset ${this.#counter}, only ${this.#buffer.length - this.#counter} available`
-      );
-    }
-    const slice = this.#buffer.subarray(this.#counter, this.#counter + length);
-    this.#counter += length;
-    return slice;
-  }
-  /** Lee un único byte. */
-  readByte() {
-    return this.read(1)[0];
-  }
-  /** Varuint LEB128: 7 bits por byte, bit 7 = continuación. */
-  readVaruint() {
-    let value = 0;
-    let shift = 0;
-    let byte;
-    do {
-      if (shift > 56) {
-        throw new VaruintOverflowError("varuint exceeds Number.MAX_SAFE_INTEGER");
-      }
-      byte = this.readByte();
-      value += (byte & 127) * 2 ** shift;
-      if (!Number.isSafeInteger(value)) {
-        throw new VaruintOverflowError("varuint exceeds Number.MAX_SAFE_INTEGER");
-      }
-      shift += 7;
-    } while (byte & 128);
-    return value;
-  }
-  /** Lee un bloque varbytes. `maxLen` es obligatorio (defensa DoS). */
-  readVarbytes(maxLen, minLen = 0) {
-    const length = this.readVaruint();
-    if (length > maxLen) {
-      throw new OversizedDataError(`varbytes length ${length} exceeds maxLen ${maxLen}`);
-    }
-    if (length < minLen) {
-      throw new OversizedDataError(`varbytes length ${length} below minLen ${minLen}`);
-    }
-    return this.read(length);
-  }
-  /** Verifica el número mágico de cabecera. */
-  assertMagic(expectedMagic) {
-    const actual = this.read(expectedMagic.length);
-    if (!bytesEqual(expectedMagic, actual)) {
-      throw new BadMagicError("header magic mismatch");
-    }
-  }
-  /** Exige que no queden bytes sin consumir. */
-  assertEof() {
-    if (this.#counter < this.#buffer.length) {
-      throw new TrailingGarbageError("trailing garbage after end of deserialized data");
-    }
-  }
-};
-var StreamSerializationContext = class {
-  #buffer = new Uint8Array(4096);
-  #length = 0;
-  get length() {
-    return this.#length;
-  }
-  getOutput() {
-    return this.#buffer.slice(0, this.#length);
-  }
-  writeByte(value) {
-    if (!Number.isInteger(value) || value < 0 || value > 255) {
-      throw new RangeError(`writeByte expects a byte 0..255; got ${value}`);
-    }
-    if (this.#length >= this.#buffer.length) {
-      const grown = new Uint8Array(this.#buffer.length * 2);
-      grown.set(this.#buffer, 0);
-      this.#buffer = grown;
-    }
-    this.#buffer[this.#length] = value;
-    this.#length += 1;
-  }
-  writeBytes(value) {
-    for (let i = 0; i < value.length; i++) {
-      this.writeByte(value[i]);
-    }
-  }
-  /** Codifica un varuint LEB128. */
-  writeVaruint(value) {
-    if (!Number.isSafeInteger(value) || value < 0) {
-      throw new RangeError(`writeVaruint expects a safe non-negative integer; got ${value}`);
-    }
-    do {
-      let byte = value % 128;
-      value = Math.floor(value / 128);
-      if (value > 0) byte |= 128;
-      this.writeByte(byte);
-    } while (value > 0);
-  }
-  writeVarbytes(value) {
-    this.writeVaruint(value.length);
-    this.writeBytes(value);
-  }
-};
-var rotl = (x, n) => x << n | x >>> 32 - n;
-function sha1(msg) {
-  let h0 = 1732584193, h1 = 4023233417, h2 = 2562383102, h3 = 271733878, h4 = 3285377520;
-  const bitLen = msg.length * 8;
-  const withOne = msg.length + 1;
-  const padded = new Uint8Array(Math.ceil((withOne + 8) / 64) * 64);
-  padded.set(msg, 0);
-  padded[msg.length] = 128;
-  const dv = new DataView(padded.buffer);
-  dv.setUint32(padded.length - 4, bitLen >>> 0, false);
-  dv.setUint32(padded.length - 8, Math.floor(bitLen / 2 ** 32), false);
-  const w = new Uint32Array(80);
-  for (let off = 0; off < padded.length; off += 64) {
-    for (let i = 0; i < 16; i++) w[i] = dv.getUint32(off + i * 4, false);
-    for (let i = 16; i < 80; i++) w[i] = rotl(w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16], 1);
-    let a = h0, b = h1, c = h2, d = h3, e = h4;
-    for (let i = 0; i < 80; i++) {
-      let f2, k;
-      if (i < 20) {
-        f2 = b & c | ~b & d;
-        k = 1518500249;
-      } else if (i < 40) {
-        f2 = b ^ c ^ d;
-        k = 1859775393;
-      } else if (i < 60) {
-        f2 = b & c | b & d | c & d;
-        k = 2400959708;
-      } else {
-        f2 = b ^ c ^ d;
-        k = 3395469782;
-      }
-      const t = rotl(a, 5) + f2 + e + k + w[i] | 0;
-      e = d;
-      d = c;
-      c = rotl(b, 30);
-      b = a;
-      a = t;
-    }
-    h0 = h0 + a | 0;
-    h1 = h1 + b | 0;
-    h2 = h2 + c | 0;
-    h3 = h3 + d | 0;
-    h4 = h4 + e | 0;
-  }
-  const out = new Uint8Array(20);
-  const odv = new DataView(out.buffer);
-  odv.setUint32(0, h0, false);
-  odv.setUint32(4, h1, false);
-  odv.setUint32(8, h2, false);
-  odv.setUint32(12, h3, false);
-  odv.setUint32(16, h4, false);
-  return out;
-}
-var K = new Uint32Array([
-  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 rotr = (x, n) => x >>> n | x << 32 - n;
-function sha256(msg) {
-  const h = new Uint32Array([
-    1779033703,
-    3144134277,
-    1013904242,
-    2773480762,
-    1359893119,
-    2600822924,
-    528734635,
-    1541459225
-  ]);
-  const bitLen = msg.length * 8;
-  const withOne = msg.length + 1;
-  const padded = new Uint8Array(Math.ceil((withOne + 8) / 64) * 64);
-  padded.set(msg, 0);
-  padded[msg.length] = 128;
-  const dv = new DataView(padded.buffer);
-  dv.setUint32(padded.length - 4, bitLen >>> 0, false);
-  dv.setUint32(padded.length - 8, Math.floor(bitLen / 2 ** 32), false);
-  const w = new Uint32Array(64);
-  for (let off = 0; off < padded.length; off += 64) {
-    for (let i = 0; i < 16; i++) w[i] = dv.getUint32(off + i * 4, false);
-    for (let i = 16; i < 64; i++) {
-      const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ w[i - 15] >>> 3;
-      const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ w[i - 2] >>> 10;
-      w[i] = w[i - 16] + s0 + w[i - 7] + s1 | 0;
-    }
-    let [a, b, c, d, e, f2, g, hh] = h;
-    for (let i = 0; i < 64; i++) {
-      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
-      const ch = e & f2 ^ ~e & g;
-      const t1 = hh + S1 + ch + K[i] + w[i] | 0;
-      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
-      const maj = a & b ^ a & c ^ b & c;
-      const t2 = S0 + maj | 0;
-      hh = g;
-      g = f2;
-      f2 = e;
-      e = d + t1 | 0;
-      d = c;
-      c = b;
-      b = a;
-      a = t1 + t2 | 0;
-    }
-    h[0] = h[0] + a | 0;
-    h[1] = h[1] + b | 0;
-    h[2] = h[2] + c | 0;
-    h[3] = h[3] + d | 0;
-    h[4] = h[4] + e | 0;
-    h[5] = h[5] + f2 | 0;
-    h[6] = h[6] + g | 0;
-    h[7] = h[7] + hh | 0;
-  }
-  const out = new Uint8Array(32);
-  const odv = new DataView(out.buffer);
-  for (let i = 0; i < 8; i++) odv.setUint32(i * 4, h[i], false);
-  return out;
-}
-var rol = (x, n) => x << n | x >>> 32 - n;
-var ZL = [
-  0,
-  1,
-  2,
-  3,
-  4,
-  5,
-  6,
-  7,
-  8,
-  9,
-  10,
-  11,
-  12,
-  13,
-  14,
-  15,
-  7,
-  4,
-  13,
-  1,
-  10,
-  6,
-  15,
-  3,
-  12,
-  0,
-  9,
-  5,
-  2,
-  14,
-  11,
-  8,
-  3,
-  10,
-  14,
-  4,
-  9,
-  15,
-  8,
-  1,
-  2,
-  7,
-  0,
-  6,
-  13,
-  11,
-  5,
-  12,
-  1,
-  9,
-  11,
-  10,
-  0,
-  8,
-  12,
-  4,
-  13,
-  3,
-  7,
-  15,
-  14,
-  5,
-  6,
-  2,
-  4,
-  0,
-  5,
-  9,
-  7,
-  12,
-  2,
-  10,
-  14,
-  1,
-  3,
-  8,
-  11,
-  6,
-  15,
-  13
-];
-var ZR = [
-  5,
-  14,
-  7,
-  0,
-  9,
-  2,
-  11,
-  4,
-  13,
-  6,
-  15,
-  8,
-  1,
-  10,
-  3,
-  12,
-  6,
-  11,
-  3,
-  7,
-  0,
-  13,
-  5,
-  10,
-  14,
-  15,
-  8,
-  12,
-  4,
-  9,
-  1,
-  2,
-  15,
-  5,
-  1,
-  3,
-  7,
-  14,
-  6,
-  9,
-  11,
-  8,
-  12,
-  2,
-  10,
-  0,
-  4,
-  13,
-  8,
-  6,
-  4,
-  1,
-  3,
-  11,
-  15,
-  0,
-  5,
-  12,
-  2,
-  13,
-  9,
-  7,
-  10,
-  14,
-  12,
-  15,
-  10,
-  4,
-  1,
-  5,
-  8,
-  7,
-  6,
-  2,
-  13,
-  14,
-  0,
-  3,
-  9,
-  11
-];
-var SL = [
-  11,
-  14,
-  15,
-  12,
-  5,
-  8,
-  7,
-  9,
-  11,
-  13,
-  14,
-  15,
-  6,
-  7,
-  9,
-  8,
-  7,
-  6,
-  8,
-  13,
-  11,
-  9,
-  7,
-  15,
-  7,
-  12,
-  15,
-  9,
-  11,
-  7,
-  13,
-  12,
-  11,
-  13,
-  6,
-  7,
-  14,
-  9,
-  13,
-  15,
-  14,
-  8,
-  13,
-  6,
-  5,
-  12,
-  7,
-  5,
-  11,
-  12,
-  14,
-  15,
-  14,
-  15,
-  9,
-  8,
-  9,
-  14,
-  5,
-  6,
-  8,
-  6,
-  5,
-  12,
-  9,
-  15,
-  5,
-  11,
-  6,
-  8,
-  13,
-  12,
-  5,
-  12,
-  13,
-  14,
-  11,
-  8,
-  5,
-  6
-];
-var SR = [
-  8,
-  9,
-  9,
-  11,
-  13,
-  15,
-  15,
-  5,
-  7,
-  7,
-  8,
-  11,
-  14,
-  14,
-  12,
-  6,
-  9,
-  13,
-  15,
-  7,
-  12,
-  8,
-  9,
-  11,
-  7,
-  7,
-  12,
-  7,
-  6,
-  15,
-  13,
-  11,
-  9,
-  7,
-  15,
-  11,
-  8,
-  6,
-  6,
-  14,
-  12,
-  13,
-  5,
-  14,
-  13,
-  13,
-  7,
-  5,
-  15,
-  5,
-  8,
-  11,
-  14,
-  14,
-  6,
-  14,
-  6,
-  9,
-  12,
-  9,
-  12,
-  5,
-  15,
-  8,
-  8,
-  5,
-  12,
-  9,
-  12,
-  5,
-  14,
-  6,
-  8,
-  13,
-  6,
-  5,
-  15,
-  13,
-  11,
-  11
-];
-var KL = [0, 1518500249, 1859775393, 2400959708, 2840853838];
-var KR = [1352829926, 1548603684, 1836072691, 2053994217, 0];
-var f = (j, x, y, z) => {
-  if (j < 16) return x ^ y ^ z;
-  if (j < 32) return x & y | ~x & z;
-  if (j < 48) return (x | ~y) ^ z;
-  if (j < 64) return x & z | y & ~z;
-  return x ^ (y | ~z);
-};
-function ripemd160(msg) {
-  let h0 = 1732584193, h1 = 4023233417, h2 = 2562383102, h3 = 271733878, h4 = 3285377520;
-  const bitLen = msg.length * 8;
-  const withOne = msg.length + 1;
-  const padded = new Uint8Array(Math.ceil((withOne + 8) / 64) * 64);
-  padded.set(msg, 0);
-  padded[msg.length] = 128;
-  const dv = new DataView(padded.buffer);
-  dv.setUint32(padded.length - 8, bitLen >>> 0, true);
-  dv.setUint32(padded.length - 4, Math.floor(bitLen / 2 ** 32), true);
-  const x = new Uint32Array(16);
-  for (let off = 0; off < padded.length; off += 64) {
-    for (let i = 0; i < 16; i++) x[i] = dv.getUint32(off + i * 4, true);
-    let al = h0, bl = h1, cl = h2, dl = h3, el = h4;
-    let ar = h0, br = h1, cr = h2, dr = h3, er = h4;
-    for (let j = 0; j < 80; j++) {
-      const round = Math.floor(j / 16);
-      let t2 = al + f(j, bl, cl, dl) + x[ZL[j]] + KL[round] | 0;
-      t2 = rol(t2, SL[j]) + el | 0;
-      al = el;
-      el = dl;
-      dl = rol(cl, 10);
-      cl = bl;
-      bl = t2;
-      t2 = ar + f(79 - j, br, cr, dr) + x[ZR[j]] + KR[round] | 0;
-      t2 = rol(t2, SR[j]) + er | 0;
-      ar = er;
-      er = dr;
-      dr = rol(cr, 10);
-      cr = br;
-      br = t2;
-    }
-    const t = h1 + cl + dr | 0;
-    h1 = h2 + dl + er | 0;
-    h2 = h3 + el + ar | 0;
-    h3 = h4 + al + br | 0;
-    h4 = h0 + bl + cr | 0;
-    h0 = t;
-  }
-  const out = new Uint8Array(20);
-  const odv = new DataView(out.buffer);
-  odv.setUint32(0, h0, true);
-  odv.setUint32(4, h1, true);
-  odv.setUint32(8, h2, true);
-  odv.setUint32(12, h3, true);
-  odv.setUint32(16, h4, true);
-  return out;
-}
-var MAX_RESULT_LENGTH = 4096;
-var MAX_MSG_LENGTH = 4096;
-function concatBytes(a, b) {
-  const out = new Uint8Array(a.length + b.length);
-  out.set(a, 0);
-  out.set(b, a.length);
-  return out;
-}
-var Op = class _Op {
-  static MAX_RESULT_LENGTH = MAX_RESULT_LENGTH;
-  static MAX_MSG_LENGTH = MAX_MSG_LENGTH;
-  /** Deserializa una operación leyendo su tag y despachando a la factoría correcta. */
-  static deserialize(ctx) {
-    return _Op.deserializeFromTag(ctx, ctx.readByte());
-  }
-  /** Igual que `deserialize`, pero con el tag ya leído del stream (lo usa el árbol Timestamp). */
-  static deserializeFromTag(ctx, tag) {
-    const factory = OP_BY_TAG.get(tag);
-    if (factory === void 0) {
-      throw new UnknownOperationError(`unknown operation tag 0x${tag.toString(16).padStart(2, "0")}`);
-    }
-    return factory(ctx);
-  }
-  get maxMsgLength() {
-    return MAX_MSG_LENGTH;
-  }
-  checkMsg(msg) {
-    if (msg.length > this.maxMsgLength) {
-      throw new MessageTooLongError(`message length ${msg.length} exceeds ${this.maxMsgLength}`);
-    }
-  }
-  checkResult(result) {
-    if (result.length > MAX_RESULT_LENGTH) {
-      throw new ResultTooLongError(`result length ${result.length} exceeds ${MAX_RESULT_LENGTH}`);
-    }
-    return result;
-  }
-};
-var OpBinary = class extends Op {
-  arg;
-  constructor(arg) {
-    super();
-    if (!(arg instanceof Uint8Array)) {
-      throw new TypeError("OpBinary arg must be a Uint8Array");
-    }
-    this.arg = arg.slice();
-  }
-  serialize(ctx) {
-    ctx.writeByte(this.tag);
-    ctx.writeVarbytes(this.arg);
-  }
-};
-var OpAppend = class _OpAppend extends OpBinary {
-  static TAG = 240;
-  tag = _OpAppend.TAG;
-  tagName = "append";
-  call(msg) {
-    this.checkMsg(msg);
-    return this.checkResult(concatBytes(msg, this.arg));
-  }
-  equals(other) {
-    return other instanceof _OpAppend && bytesEqual(this.arg, other.arg);
-  }
-};
-var OpPrepend = class _OpPrepend extends OpBinary {
-  static TAG = 241;
-  tag = _OpPrepend.TAG;
-  tagName = "prepend";
-  call(msg) {
-    this.checkMsg(msg);
-    return this.checkResult(concatBytes(this.arg, msg));
-  }
-  equals(other) {
-    return other instanceof _OpPrepend && bytesEqual(this.arg, other.arg);
-  }
-};
-var OpUnary = class extends Op {
-  serialize(ctx) {
-    ctx.writeByte(this.tag);
-  }
-};
-var OpReverse = class _OpReverse extends OpUnary {
-  static TAG = 242;
-  tag = _OpReverse.TAG;
-  tagName = "reverse";
-  call(msg) {
-    this.checkMsg(msg);
-    const r = new Uint8Array(msg.length);
-    for (let i = 0; i < msg.length; i++) r[i] = msg[msg.length - 1 - i];
-    return this.checkResult(r);
-  }
-  equals(other) {
-    return other instanceof _OpReverse;
-  }
-};
-var OpHexlify = class _OpHexlify extends OpUnary {
-  static TAG = 243;
-  tag = _OpHexlify.TAG;
-  tagName = "hexlify";
-  // El resultado mide el doble que el mensaje; el límite de mensaje es la mitad.
-  get maxMsgLength() {
-    return MAX_RESULT_LENGTH / 2;
-  }
-  call(msg) {
-    this.checkMsg(msg);
-    return this.checkResult(textToBytes(bytesToHex(msg)));
-  }
-  equals(other) {
-    return other instanceof _OpHexlify;
-  }
-};
-var CryptOp = class extends OpUnary {
-  call(msg) {
-    this.checkMsg(msg);
-    return this.hash(msg);
-  }
-  /**
-   * Hashea el contenido COMPLETO de un fichero (longitud arbitraria) con el algoritmo
-   * de esta operación. A diferencia de `call`, NO aplica el límite `MAX_MSG_LENGTH`:
-   * `call` transforma digests dentro del árbol de prueba (≤ 4096 bytes), mientras que
-   * `hashFile` recibe el contenido íntegro del fichero a sellar, que puede ser de
-   * cualquier tamaño. Lo usa `DetachedTimestampFile.fromBytes`.
-   */
-  hashFile(data) {
-    if (!(data instanceof Uint8Array)) {
-      throw new TypeError("hashFile expects a Uint8Array");
-    }
-    return this.hash(data);
-  }
-};
-var OpSHA1 = class _OpSHA1 extends CryptOp {
-  static TAG = 2;
-  tag = _OpSHA1.TAG;
-  tagName = "sha1";
-  digestLength = 20;
-  hash(msg) {
-    return sha1(msg);
-  }
-  equals(other) {
-    return other instanceof _OpSHA1;
-  }
-};
-var OpRIPEMD160 = class _OpRIPEMD160 extends CryptOp {
-  static TAG = 3;
-  tag = _OpRIPEMD160.TAG;
-  tagName = "ripemd160";
-  digestLength = 20;
-  hash(msg) {
-    return ripemd160(msg);
-  }
-  equals(other) {
-    return other instanceof _OpRIPEMD160;
-  }
-};
-var OpSHA256 = class _OpSHA256 extends CryptOp {
-  static TAG = 8;
-  tag = _OpSHA256.TAG;
-  tagName = "sha256";
-  digestLength = 32;
-  hash(msg) {
-    return sha256(msg);
-  }
-  equals(other) {
-    return other instanceof _OpSHA256;
-  }
-};
-var unary = (ctor) => () => new ctor();
-var binary = (ctor) => (ctx) => new ctor(ctx.readVarbytes(MAX_RESULT_LENGTH, 1));
-function buildTagTable(entries) {
-  const map = /* @__PURE__ */ new Map();
-  for (const [tag, factory] of entries) {
-    if (map.has(tag)) {
-      throw new Error(`duplicate operation tag 0x${tag.toString(16)}`);
-    }
-    map.set(tag, factory);
-  }
-  return map;
-}
-var OP_BY_TAG = buildTagTable([
-  [OpAppend.TAG, binary(OpAppend)],
-  [OpPrepend.TAG, binary(OpPrepend)],
-  [OpReverse.TAG, unary(OpReverse)],
-  [OpHexlify.TAG, unary(OpHexlify)],
-  [OpSHA1.TAG, unary(OpSHA1)],
-  [OpRIPEMD160.TAG, unary(OpRIPEMD160)],
-  [OpSHA256.TAG, unary(OpSHA256)]
-]);
-var TAG_SIZE = 8;
-var MAX_PAYLOAD_SIZE = 8192;
-var MAX_URI_LENGTH = 1e3;
-var ALLOWED_URI_CHARS = new Set(
-  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._/:"
-);
-var PENDING_TAG = new Uint8Array([131, 223, 227, 13, 46, 249, 12, 142]);
-var BITCOIN_TAG = new Uint8Array([5, 136, 150, 13, 115, 215, 25, 1]);
-var LITECOIN_TAG = new Uint8Array([6, 134, 154, 13, 115, 215, 27, 69]);
-function decodeAndValidateUri(bytes) {
-  if (bytes.length === 0) {
-    throw new InvalidUriError("pending attestation URI is empty");
-  }
-  if (bytes.length > MAX_URI_LENGTH) {
-    throw new InvalidUriError(`pending attestation URI exceeds ${MAX_URI_LENGTH} bytes`);
-  }
-  let uri = "";
-  for (let i = 0; i < bytes.length; i++) {
-    const byte = bytes[i];
-    const char = String.fromCharCode(byte);
-    if (!ALLOWED_URI_CHARS.has(char)) {
-      throw new InvalidUriError(
-        `pending attestation URI contains invalid byte 0x${byte.toString(16).padStart(2, "0")}`
-      );
-    }
-    uri += char;
-  }
-  return uri;
-}
-function deserializeAttestation(ctx) {
-  const tag = ctx.read(TAG_SIZE).slice();
-  const payload = ctx.readVarbytes(MAX_PAYLOAD_SIZE);
-  const payloadCtx = new StreamDeserializationContext(payload);
-  let attestation;
-  if (bytesEqual(tag, PENDING_TAG)) {
-    const uriBytes = payloadCtx.readVarbytes(MAX_URI_LENGTH).slice();
-    attestation = { kind: "pending", tag, uri: decodeAndValidateUri(uriBytes), uriBytes };
-  } else if (bytesEqual(tag, BITCOIN_TAG)) {
-    attestation = { kind: "bitcoin", tag, height: payloadCtx.readVaruint() };
-  } else if (bytesEqual(tag, LITECOIN_TAG)) {
-    attestation = { kind: "litecoin", tag, height: payloadCtx.readVaruint() };
-  } else {
-    return { kind: "unknown", tag, payload: payload.slice() };
-  }
-  payloadCtx.assertEof();
-  return attestation;
-}
-function serializePayload(ctx, att) {
-  switch (att.kind) {
-    case "pending":
-      ctx.writeVarbytes(att.uriBytes);
-      return;
-    case "bitcoin":
-    case "litecoin":
-      ctx.writeVaruint(att.height);
-      return;
-    case "unknown":
-      ctx.writeBytes(att.payload);
-      return;
-  }
-}
-function serializeAttestation(ctx, att) {
-  ctx.writeBytes(att.tag);
-  const payloadCtx = new StreamSerializationContext();
-  serializePayload(payloadCtx, att);
-  ctx.writeVarbytes(payloadCtx.getOutput());
-}
-function compareAttestations(a, b) {
-  const deltaTag = compareBytes(a.tag, b.tag);
-  if (deltaTag !== 0) {
-    return deltaTag;
-  }
-  switch (a.kind) {
-    case "pending":
-      return compareBytes(a.uriBytes, b.uriBytes);
-    case "bitcoin":
-    case "litecoin":
-      return a.height - b.height;
-    case "unknown":
-      return compareBytes(a.payload, b.payload);
-  }
-}
-function attestationsEqual(a, b) {
-  if (a.kind !== b.kind || !bytesEqual(a.tag, b.tag)) {
-    return false;
-  }
-  switch (a.kind) {
-    case "pending":
-      return bytesEqual(a.uriBytes, b.uriBytes);
-    case "bitcoin":
-    case "litecoin":
-      return a.height === b.height;
-    case "unknown":
-      return bytesEqual(a.payload, b.payload);
-  }
-}
-var MERKLEROOT_RE = /^[0-9a-fA-F]{64}$/;
-function verifyAgainstBlockheader(digest, block) {
-  if (digest.length !== 32) {
-    throw new VerificationError(`expected digest of 32 bytes; got ${digest.length}`);
-  }
-  if (typeof block.merkleroot !== "string" || !MERKLEROOT_RE.test(block.merkleroot)) {
-    throw new VerificationError("block merkleroot is not a 64-char hex string");
-  }
-  if (!Number.isInteger(block.time) || block.time <= 0) {
-    throw new VerificationError("block time is not a positive integer");
-  }
-  if (!bytesEqual(digest, hexToBytes(block.merkleroot))) {
-    throw new VerificationError("digest does not match block merkleroot");
-  }
-  return block.time;
-}
-var MAX_TREE_DEPTH = 256;
-function opToBytes(op) {
-  const ctx = new StreamSerializationContext();
-  op.serialize(ctx);
-  return ctx.getOutput();
-}
-function opKey(op) {
-  return bytesToHex(opToBytes(op));
-}
-var Timestamp = class _Timestamp {
-  /** Digest de este nodo (copia defensiva, no comparte memoria con la entrada). */
-  msg;
-  /** Sellos directos sobre `msg`. El cliente puede añadir con `.push()`. */
-  attestations = [];
-  /** Ramas indexadas por la serialización canónica (hex) de su op. */
-  #ops = /* @__PURE__ */ new Map();
-  constructor(msg) {
-    if (!(msg instanceof Uint8Array)) {
-      throw new TypeError("Timestamp msg must be a Uint8Array");
-    }
-    if (msg.length > Op.MAX_MSG_LENGTH) {
-      throw new TypeError(`Timestamp msg length ${msg.length} exceeds ${Op.MAX_MSG_LENGTH}`);
-    }
-    this.msg = msg.slice();
-  }
-  /** El digest de este nodo (copia: mutar el resultado no afecta al árbol). */
-  getDigest() {
-    return this.msg.slice();
-  }
-  /** Las ramas (op + sub-timestamp) de este nodo, como array de solo lectura. */
-  get branches() {
-    return [...this.#ops.values()];
-  }
-  /**
-   * Deserializa un Timestamp. El formato no incluye el mensaje sobre el que opera,
-   * así que hay que aportarlo (`initialMsg`) para recalcular los resultados de las ops.
-   * @param depth profundidad actual; protege contra árboles maliciosamente profundos.
-   */
-  static deserialize(ctx, initialMsg, depth = 0) {
-    if (depth > MAX_TREE_DEPTH) {
-      throw new OversizedDataError(`timestamp tree exceeds max depth ${MAX_TREE_DEPTH}`);
-    }
-    const self = new _Timestamp(initialMsg);
-    let tag = ctx.readByte();
-    while (tag === 255) {
-      self.#deserializeElement(ctx, ctx.readByte(), depth);
-      tag = ctx.readByte();
-    }
-    self.#deserializeElement(ctx, tag, depth);
-    return self;
-  }
-  #deserializeElement(ctx, tag, depth) {
-    if (tag === 0) {
-      this.attestations.push(deserializeAttestation(ctx));
-      return;
-    }
-    const op = Op.deserializeFromTag(ctx, tag);
-    let result;
-    try {
-      result = op.call(this.msg);
-    } catch (err) {
-      throw new DeserializationError(
-        `operation failed during deserialization: ${err.message}`
-      );
-    }
-    const stamp = _Timestamp.deserialize(ctx, result, depth + 1);
-    this.#ops.set(opKey(op), { op, stamp });
-  }
-  /** Serializa este nodo en orden canónico (determinista byte-a-byte). */
-  serialize(ctx) {
-    const attestations = [...this.attestations].sort(compareAttestations);
-    const branches = [...this.#ops.values()].sort(
-      (a, b) => compareBytes(opToBytes(a.op), opToBytes(b.op))
-    );
-    const total = attestations.length + branches.length;
-    if (total === 0) {
-      throw new EmptyTimestampError("an empty timestamp cannot be serialized");
-    }
-    let index = 0;
-    for (const attestation of attestations) {
-      if (index < total - 1) ctx.writeByte(255);
-      ctx.writeByte(0);
-      serializeAttestation(ctx, attestation);
-      index++;
-    }
-    for (const { op, stamp } of branches) {
-      if (index < total - 1) ctx.writeByte(255);
-      op.serialize(ctx);
-      stamp.serialize(ctx);
-      index++;
-    }
-  }
-  /**
-   * Añade una op a este nodo y devuelve el sub-timestamp de su resultado.
-   * Si la op (por contenido) ya existe, devuelve la rama existente.
-   */
-  add(op) {
-    const key = opKey(op);
-    const existing = this.#ops.get(key);
-    if (existing !== void 0) {
-      return existing.stamp;
-    }
-    const stamp = new _Timestamp(op.call(this.msg));
-    this.#ops.set(key, { op, stamp });
-    return stamp;
-  }
-  /**
-   * Vincula `op` a un sub-timestamp YA EXISTENTE, compartiendo el objeto (no crea uno nuevo).
-   * A diferencia de `add`, hace que esta rama apunte al mismo `Timestamp` que otra rama
-   * (de otro nodo) ya construyó, de modo que las attestations añadidas más arriba sean
-   * alcanzables desde ambos caminos. Lo usa el árbol Merkle para el cross-link izquierda/derecha.
-   * Falla (fail-closed) si `stamp` no es un Timestamp o si `op.call(this.msg)` no coincide con `stamp.msg`.
-   */
-  addExisting(op, stamp) {
-    if (!(stamp instanceof _Timestamp)) {
-      throw new TypeError("addExisting requires a Timestamp");
-    }
-    if (!bytesEqual(op.call(this.msg), stamp.msg)) {
-      throw new MergeError("operation result does not match the existing timestamp message");
-    }
-    this.#ops.set(opKey(op), { op, stamp });
-    return stamp;
-  }
-  /** Incorpora las attestations y ramas de `other` (mismo `msg`) en este timestamp. */
-  merge(other) {
-    if (!(other instanceof _Timestamp)) {
-      throw new MergeError("can only merge Timestamps together");
-    }
-    if (!bytesEqual(this.msg, other.msg)) {
-      throw new MergeError("cannot merge timestamps for different messages");
-    }
-    for (const attestation of other.attestations) {
-      if (!this.attestations.some((existing) => attestationsEqual(existing, attestation))) {
-        this.attestations.push(attestation);
-      }
-    }
-    for (const { op, stamp } of other.#ops.values()) {
-      const key = opKey(op);
-      let branch = this.#ops.get(key);
-      if (branch === void 0) {
-        branch = { op, stamp: new _Timestamp(op.call(this.msg)) };
-        this.#ops.set(key, branch);
-      }
-      branch.stamp.merge(stamp);
-    }
-  }
-  /** Todas las attestations del árbol con el msg de su nodo (sin pérdida de datos). */
-  allAttestations() {
-    const result = [];
-    for (const attestation of this.attestations) {
-      result.push({ msg: this.msg.slice(), attestation });
-    }
-    for (const { stamp } of this.#ops.values()) {
-      result.push(...stamp.allAttestations());
-    }
-    return result;
-  }
-  /** Todas las attestations del árbol (sin el msg asociado). */
-  getAttestations() {
-    return this.allAttestations().map((entry) => entry.attestation);
-  }
-  /** Verdadero si el árbol contiene una attestation verificable localmente (Bitcoin/Litecoin). */
-  isTimestampComplete() {
-    return this.allAttestations().some(
-      ({ attestation }) => attestation.kind === "bitcoin" || attestation.kind === "litecoin"
-    );
-  }
-  /** Sub-timestamps que tienen attestations directas. */
-  directlyVerified() {
-    if (this.attestations.length > 0) {
-      return [this];
-    }
-    const result = [];
-    for (const { stamp } of this.#ops.values()) {
-      result.push(...stamp.directlyVerified());
-    }
-    return result;
-  }
-  /** Los mensajes de las hojas del árbol (nodos sin ops). */
-  allTips() {
-    if (this.#ops.size === 0) {
-      return [this.msg.slice()];
-    }
-    const result = [];
-    for (const { stamp } of this.#ops.values()) {
-      result.push(...stamp.allTips());
-    }
-    return result;
-  }
-  /** Igualdad estructural recursiva con otro timestamp. */
-  equals(other) {
-    if (!(other instanceof _Timestamp)) {
-      return false;
-    }
-    if (!bytesEqual(this.msg, other.msg)) {
-      return false;
-    }
-    if (this.attestations.length !== other.attestations.length) {
-      return false;
-    }
-    const ours = [...this.attestations].sort(compareAttestations);
-    const theirs = [...other.attestations].sort(compareAttestations);
-    for (let i = 0; i < ours.length; i++) {
-      if (!attestationsEqual(ours[i], theirs[i])) {
-        return false;
-      }
-    }
-    if (this.#ops.size !== other.#ops.size) {
-      return false;
-    }
-    for (const [key, branch] of this.#ops) {
-      const otherBranch = other.#ops.get(key);
-      if (otherBranch === void 0) {
-        return false;
-      }
-      if (!branch.stamp.equals(otherBranch.stamp)) {
-        return false;
-      }
-    }
-    return true;
-  }
-};
-function catSha256(left, right) {
-  if (!(left instanceof Timestamp) || !(right instanceof Timestamp)) {
-    throw new TypeError("catSha256 requires two Timestamps");
-  }
-  const concat = right.add(new OpPrepend(left.msg));
-  left.addExisting(new OpAppend(right.msg), concat);
-  return concat.add(new OpSHA256());
-}
-function makeMerkleTree(timestamps) {
-  if (timestamps.length === 0) {
-    throw new EmptyMerkleTreeError("makeMerkleTree requires at least one timestamp");
-  }
-  for (const stamp of timestamps) {
-    if (!(stamp instanceof Timestamp)) {
-      throw new TypeError("makeMerkleTree requires an array of Timestamps");
-    }
-  }
-  let round = [...timestamps];
-  while (round.length > 1) {
-    const next = [];
-    for (let i = 0; i < round.length; i += 2) {
-      if (i + 1 < round.length) {
-        next.push(catSha256(round[i], round[i + 1]));
-      } else {
-        next.push(round[i]);
-      }
-    }
-    round = next;
-  }
-  return round[0];
-}
-var HEADER_MAGIC = new Uint8Array([
-  0,
-  79,
-  112,
-  101,
-  110,
-  84,
-  105,
-  109,
-  101,
-  115,
-  116,
-  97,
-  109,
-  112,
-  115,
-  0,
-  0,
-  80,
-  114,
-  111,
-  111,
-  102,
-  0,
-  191,
-  137,
-  226,
-  232,
-  132,
-  232,
-  146,
-  148
-]);
-var MAJOR_VERSION = 1;
-var DetachedTimestampFile = class _DetachedTimestampFile {
-  fileHashOp;
-  timestamp;
-  constructor(fileHashOp, timestamp) {
-    if (!(fileHashOp instanceof CryptOp)) {
-      throw new TypeError("DetachedTimestampFile: fileHashOp must be a CryptOp");
-    }
-    if (!(timestamp instanceof Timestamp)) {
-      throw new TypeError("DetachedTimestampFile: timestamp must be a Timestamp");
-    }
-    if (timestamp.msg.length !== fileHashOp.digestLength) {
-      throw new TypeError(
-        `DetachedTimestampFile: timestamp message length ${timestamp.msg.length} does not match ${fileHashOp.tagName} digest length ${fileHashOp.digestLength}`
-      );
-    }
-    this.fileHashOp = fileHashOp;
-    this.timestamp = timestamp;
-  }
-  /** Digest del fichero sellado (copia defensiva: mutarla no afecta al objeto). */
-  fileDigest() {
-    return this.timestamp.getDigest();
-  }
-  /** Escribe el fichero `.ots` en el contexto: magic → versión → op → digest → árbol. */
-  serialize(ctx) {
-    ctx.writeBytes(HEADER_MAGIC);
-    ctx.writeVaruint(MAJOR_VERSION);
-    this.fileHashOp.serialize(ctx);
-    ctx.writeBytes(this.timestamp.msg);
-    this.timestamp.serialize(ctx);
-  }
-  /** Serializa el fichero `.ots` completo a bytes. */
-  serializeToBytes() {
-    const ctx = new StreamSerializationContext();
-    this.serialize(ctx);
-    return ctx.getOutput();
-  }
-  /**
-   * Lee un fichero `.ots` desde bytes. Único tipo de entrada: `Uint8Array` (fail-closed;
-   * elimina los 4 tipos del original y el bug `Array.from(ArrayBuffer) → []`).
-   */
-  static deserialize(input) {
-    if (!(input instanceof Uint8Array)) {
-      throw new TypeError("DetachedTimestampFile.deserialize expects a Uint8Array");
-    }
-    const ctx = new StreamDeserializationContext(input);
-    ctx.assertMagic(HEADER_MAGIC);
-    const major = ctx.readVaruint();
-    if (major !== MAJOR_VERSION) {
-      throw new UnsupportedVersionError(`unsupported .ots major version ${major}`);
-    }
-    const op = Op.deserialize(ctx);
-    if (!(op instanceof CryptOp)) {
-      throw new DeserializationError("file hash operation must be a cryptographic hash");
-    }
-    const fileHash = ctx.read(op.digestLength);
-    const timestamp = Timestamp.deserialize(ctx, fileHash);
-    ctx.assertEof();
-    return new _DetachedTimestampFile(op, timestamp);
-  }
-  /** Crea un `.ots` nuevo hasheando el contenido completo de un fichero. */
-  static fromBytes(fileHashOp, fileContent) {
-    if (!(fileHashOp instanceof CryptOp)) {
-      throw new TypeError("DetachedTimestampFile.fromBytes: fileHashOp must be a CryptOp");
-    }
-    const digest = fileHashOp.hashFile(fileContent);
-    return new _DetachedTimestampFile(fileHashOp, new Timestamp(digest));
-  }
-  /** Crea un `.ots` nuevo a partir de un digest ya calculado del fichero. */
-  static fromHash(fileHashOp, fileDigest) {
-    return new _DetachedTimestampFile(fileHashOp, new Timestamp(fileDigest));
-  }
-  /** Igualdad estructural con otro fichero `.ots`. */
-  equals(other) {
-    return other instanceof _DetachedTimestampFile && this.fileHashOp.equals(other.fileHashOp) && this.timestamp.equals(other.timestamp);
-  }
-};
+// src/core/orchestration.ts
+var import_core4 = require("@otskit/core");
 
 // src/network/calendar.ts
+var import_core2 = require("@otskit/core");
 var MAX_CALENDAR_RESPONSE_SIZE = 1e4;
 function assertCommitment(bytes) {
   if (!(bytes instanceof Uint8Array)) {
@@ -1917,7 +515,7 @@ var CalendarClient = class {
   url;
   networkLayer;
   logger;
-  /** Envía un digest al calendario y devuelve el Timestamp que lo commit-ea. */
+  /** Envia un digest al calendario y devuelve el Timestamp que lo commit-ea. */
   async submit(digest, signal) {
     assertCommitment(digest);
     this.logger?.debug(`Submitting digest to ${this.url}/digest`);
@@ -1928,10 +526,10 @@ var CalendarClient = class {
     );
     return this.#parseTimestamp(response.data, digest);
   }
-  /** Pregunta al calendario si tiene un Timestamp más completo para `commitment` (upgrade). */
+  /** Pregunta al calendario si tiene un Timestamp mas completo para `commitment` (upgrade). */
   async getTimestamp(commitment, signal) {
     assertCommitment(commitment);
-    const path = `/timestamp/${bytesToHex(commitment)}`;
+    const path = `/timestamp/${(0, import_core2.bytesToHex)(commitment)}`;
     this.logger?.debug(`Querying ${this.url}${path}`);
     let response;
     try {
@@ -1957,62 +555,85 @@ var CalendarClient = class {
         `calendar response of ${data.length} bytes exceeds limit ${MAX_CALENDAR_RESPONSE_SIZE}`
       );
     }
-    const ctx = new StreamDeserializationContext(data);
-    const timestamp = Timestamp.deserialize(ctx, commitment);
+    const ctx = new import_core2.StreamDeserializationContext(data);
+    const timestamp = import_core2.Timestamp.deserialize(ctx, commitment);
     ctx.assertEof();
     return timestamp;
   }
 };
-function wildcardToRegExp(pattern) {
-  const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\\\*/g, "[^/]*");
-  return new RegExp(`^${escaped}$`, "i");
+function parseWhitelistPattern(raw) {
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    return void 0;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return void 0;
+  const hostname = parsed.hostname.toLowerCase();
+  const wildcardSuffix = hostname.startsWith("*.") ? hostname.slice(2) : void 0;
+  if (hostname.includes("*") && wildcardSuffix === void 0) return void 0;
+  if (wildcardSuffix !== void 0 && (wildcardSuffix.length === 0 || wildcardSuffix.includes("*"))) return void 0;
+  return {
+    protocol: parsed.protocol,
+    hostname,
+    port: parsed.port,
+    pathname: parsed.pathname,
+    wildcardSuffix
+  };
+}
+function hostnameMatchesPattern(hostname, pattern) {
+  if (pattern.wildcardSuffix === void 0) return hostname === pattern.hostname;
+  if (!hostname.endsWith("." + pattern.wildcardSuffix)) return false;
+  const label = hostname.slice(0, -pattern.wildcardSuffix.length - 1);
+  return label.length > 0 && !label.includes(".");
 }
 var UrlWhitelist = class {
-  #patterns = /* @__PURE__ */ new Set();
+  #patterns = /* @__PURE__ */ new Map();
   constructor(urls) {
     if (urls) {
       for (const u of urls) this.add(u);
     }
   }
-  /** Añade un patrón; si no trae esquema, se añaden las variantes http y https. */
+  /** Anade un patron; si no trae esquema, se anaden las variantes http y https. */
   add(url) {
     if (typeof url !== "string") {
       throw new TypeError("UrlWhitelist: URL must be a string");
     }
     if (url.startsWith("http://") || url.startsWith("https://")) {
-      this.#patterns.add(url);
+      const pattern = parseWhitelistPattern(url);
+      if (pattern !== void 0) this.#patterns.set(url, pattern);
     } else {
-      this.#patterns.add("http://" + url);
-      this.#patterns.add("https://" + url);
+      this.add("http://" + url);
+      this.add("https://" + url);
     }
   }
-  /** Verdadero si `url` casa con algún patrón de la whitelist. */
+  /** Verdadero si `url` casa con algun patron de la whitelist. */
   contains(url) {
-    for (const pattern of this.#patterns) {
-      if (wildcardToRegExp(pattern).test(url)) return true;
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch {
+      return false;
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return false;
+    if (parsed.search !== "" || parsed.hash !== "") return false;
+    const hostname = parsed.hostname.toLowerCase();
+    for (const pattern of this.#patterns.values()) {
+      if (parsed.protocol !== pattern.protocol || parsed.port !== pattern.port) continue;
+      if (parsed.pathname !== pattern.pathname) continue;
+      if (hostnameMatchesPattern(hostname, pattern)) return true;
     }
     return false;
   }
   toString() {
-    return `UrlWhitelist([${[...this.#patterns].join(", ")}])`;
+    return `UrlWhitelist([${[...this.#patterns.keys()].join(", ")}])`;
   }
 };
-var DEFAULT_CALENDAR_WHITELIST = new UrlWhitelist([
-  "https://*.calendar.opentimestamps.org",
-  // Peter Todd
-  "https://*.calendar.eternitywall.com",
-  // Eternity Wall
-  "https://*.calendar.catallaxy.com"
-  // Catallaxy
-]);
-var DEFAULT_AGGREGATORS = [
-  "https://a.pool.opentimestamps.org",
-  "https://b.pool.opentimestamps.org",
-  "https://a.pool.eternitywall.com",
-  "https://ots.btc.catallaxy.com"
-];
+var DEFAULT_CALENDAR_WHITELIST = new UrlWhitelist([...import_core2.TRUSTED_CALENDAR_WHITELIST_PATTERNS]);
+var DEFAULT_AGGREGATORS = [...import_core2.DEFAULT_AGGREGATOR_URLS];
 
 // src/network/esplora.ts
+var import_core3 = require("@otskit/core");
 var PUBLIC_ESPLORA_URL = "https://blockstream.info/api";
 var MAX_ESPLORA_RESPONSE_SIZE = 1e5;
 var HEX64_RE = /^[0-9a-f]{64}$/i;
@@ -2092,19 +713,125 @@ var EsploraClient = class {
         `esplora response of ${data.length} bytes exceeds limit ${MAX_ESPLORA_RESPONSE_SIZE}`
       );
     }
-    return new TextDecoder("utf-8", { fatal: false }).decode(data);
+    try {
+      return new TextDecoder("utf-8", { fatal: true }).decode(data);
+    } catch (cause) {
+      throw new EsploraResponseError("esplora response contains invalid UTF-8 bytes", {
+        cause: cause instanceof Error ? cause : void 0
+      });
+    }
   }
 };
 async function verifyTimestampAttestation(digest, attestation, explorer, signal) {
   if (attestation.kind !== "bitcoin" && attestation.kind !== "litecoin") {
-    throw new VerificationError(`cannot verify a '${attestation.kind}' attestation against the chain`);
+    throw new import_core3.VerificationError(`cannot verify a '${attestation.kind}' attestation against the chain`);
   }
   const hash = await explorer.blockHash(attestation.height, signal);
   const header = await explorer.block(hash, signal);
-  return verifyAgainstBlockheader(digest, header);
+  return (0, import_core3.verifyAgainstBlockheader)(digest, header);
 }
 
 // src/core/orchestration.ts
+var import_node_crypto = require("crypto");
+
+// src/security/ssrf.ts
+var import_promises = require("dns/promises");
+var import_node_net = require("net");
+var BLOCKED_CIDRS_V4 = [
+  { network: 0, mask: 4278190080, label: "0.0.0.0/8 (This Network)" },
+  { network: 167772160, mask: 4278190080, label: "10.0.0.0/8 (RFC 1918)" },
+  { network: 2130706432, mask: 4278190080, label: "127.0.0.0/8 (Loopback)" },
+  { network: 2851995648, mask: 4294901760, label: "169.254.0.0/16 (Link-local/IMDS)" },
+  { network: 2886729728, mask: 4293918720, label: "172.16.0.0/12 (RFC 1918)" },
+  { network: 3232235520, mask: 4294901760, label: "192.168.0.0/16 (RFC 1918)" },
+  { network: 3323068416, mask: 4294836224, label: "198.18.0.0/15 (Benchmarking)" },
+  { network: 3758096384, mask: 4026531840, label: "224.0.0.0/4 (Multicast)" },
+  { network: 4026531840, mask: 4026531840, label: "240.0.0.0/4 (Reserved)" },
+  { network: 4294967295, mask: 4294967295, label: "255.255.255.255 (Broadcast)" }
+];
+function ipv4ToUint32(ip) {
+  const parts = ip.split(".");
+  return (parseInt(parts[0], 10) << 24 | parseInt(parts[1], 10) << 16 | parseInt(parts[2], 10) << 8 | parseInt(parts[3], 10)) >>> 0;
+}
+function assertNotPrivateIPv4(ip, calendarUrl) {
+  const n = ipv4ToUint32(ip);
+  for (const cidr of BLOCKED_CIDRS_V4) {
+    if ((n & cidr.mask) >>> 0 === cidr.network) {
+      throw new ValidationError(
+        `Calendar URL "${calendarUrl}" resolves to a private/reserved IPv4 address (${ip} \u2014 ${cidr.label}). Set allowPrivateCalendars: true to override.`
+      );
+    }
+  }
+}
+var BLOCKED_IPV6_PREFIXES = [
+  { prefix: "::1", label: "Loopback" },
+  { prefix: "::", label: "Unspecified" },
+  { prefix: "fc", label: "fc00::/7 (Unique Local)" },
+  { prefix: "fd", label: "fd00::/8 (Unique Local)" },
+  { prefix: "fe8", label: "fe80::/10 (Link-local)" },
+  { prefix: "fe9", label: "fe80::/10 (Link-local)" },
+  { prefix: "fea", label: "fe80::/10 (Link-local)" },
+  { prefix: "feb", label: "fe80::/10 (Link-local)" },
+  { prefix: "ff", label: "ff00::/8 (Multicast)" },
+  { prefix: "::ffff:", label: "IPv4-mapped IPv6" },
+  { prefix: "64:ff9b:", label: "64:ff9b::/96 (NAT64)" },
+  { prefix: "2001:db8", label: "2001:db8::/32 (Documentation)" }
+];
+function assertNotPrivateIPv6(ip, calendarUrl) {
+  const lower = ip.toLowerCase();
+  for (const { prefix, label } of BLOCKED_IPV6_PREFIXES) {
+    if (lower === prefix || lower.startsWith(prefix)) {
+      throw new ValidationError(
+        `Calendar URL "${calendarUrl}" resolves to a private/reserved IPv6 address (${ip} \u2014 ${label}). Set allowPrivateCalendars: true to override.`
+      );
+    }
+  }
+}
+async function assertSafeCalendarUrl(url, options) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new ValidationError(`Calendar URL is not valid: "${url}"`);
+  }
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+    throw new ValidationError(`Calendar URL must use http or https: "${url}"`);
+  }
+  if (parsed.username || parsed.password) {
+    throw new ValidationError(`Calendar URL must not contain embedded credentials: "${url}"`);
+  }
+  if (options.allowPrivate) return;
+  const hostname = parsed.hostname;
+  const host = hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+  const ipVersion = (0, import_node_net.isIP)(host);
+  if (ipVersion === 4) {
+    assertNotPrivateIPv4(host, url);
+    return;
+  }
+  if (ipVersion === 6) {
+    assertNotPrivateIPv6(host, url);
+    return;
+  }
+  let addresses;
+  try {
+    addresses = await (0, import_promises.lookup)(hostname, { all: true });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new ValidationError(
+      `Calendar URL hostname "${hostname}" could not be resolved: ${message}`
+    );
+  }
+  if (addresses.length === 0) {
+    throw new ValidationError(`Calendar URL hostname "${hostname}" resolved to no addresses`);
+  }
+  for (const { address, family } of addresses) {
+    if (family === 4) assertNotPrivateIPv4(address, url);
+    else if (family === 6) assertNotPrivateIPv6(address, url);
+  }
+}
+
+// src/core/orchestration.ts
+var MAX_BITCOIN_ATTESTATIONS = 10;
 function validateHash(hash) {
   if (typeof hash === "string") {
     const hex = hash.trim().toLowerCase();
@@ -2126,19 +853,12 @@ function secureNonce(n) {
   globalThis.crypto.getRandomValues(bytes);
   return bytes;
 }
-var bytesEq = (a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b)) === 0;
-function assertHttpUrl(url, label) {
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
-    throw new ValidationError(`${label} is not a valid URL: ${url}`);
-  }
-  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
-    throw new ValidationError(`${label} must use http(s): ${url}`);
-  }
+function timingSafeEq(a, b) {
+  if (a.length !== b.length) return false;
+  return (0, import_node_crypto.timingSafeEqual)(a, b);
 }
-async function orchestrateStamp(hash, calendars, networkLayer, logger, signal, minimumSuccessfulSubmissions = 2) {
+var bytesEqFast = (a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b)) === 0;
+async function orchestrateStamp(hash, calendars, networkLayer, logger, signal, minimumSuccessfulSubmissions = 2, allowPrivateCalendars = false) {
   if (calendars.length === 0) {
     throw new ValidationError("at least one calendar is required to stamp");
   }
@@ -2150,13 +870,15 @@ async function orchestrateStamp(hash, calendars, networkLayer, logger, signal, m
       `minimumSuccessfulSubmissions (${minimumSuccessfulSubmissions}) cannot exceed the number of calendars (${calendars.length})`
     );
   }
-  for (const url of calendars) assertHttpUrl(url, "calendar");
+  await Promise.all(
+    calendars.map((url) => assertSafeCalendarUrl(url, { allowPrivate: allowPrivateCalendars }))
+  );
   const digest = validateHash(hash);
   logger?.info(`Starting stamp for ${Buffer.from(digest).toString("hex")}`);
-  const detached = DetachedTimestampFile.fromHash(new OpSHA256(), digest);
-  const nonceAppended = detached.timestamp.add(new OpAppend(secureNonce(16)));
-  const merkleRoot = nonceAppended.add(new OpSHA256());
-  const merkleTip = makeMerkleTree([merkleRoot]);
+  const detached = import_core4.DetachedTimestampFile.fromHash(new import_core4.OpSHA256(), digest);
+  const nonceAppended = detached.timestamp.add(new import_core4.OpAppend(secureNonce(16)));
+  const merkleRoot = nonceAppended.add(new import_core4.OpSHA256());
+  const merkleTip = (0, import_core4.makeMerkleTree)([merkleRoot]);
   const results = await Promise.allSettled(
     calendars.map((url) => new CalendarClient(url, networkLayer, logger).submit(merkleTip.getDigest(), signal))
   );
@@ -2186,7 +908,7 @@ async function orchestrateStamp(hash, calendars, networkLayer, logger, signal, m
 async function orchestrateUpgrade(incompleteProof, _calendars, networkLayer, logger, signal) {
   let detached;
   try {
-    detached = DetachedTimestampFile.deserialize(new Uint8Array(incompleteProof));
+    detached = import_core4.DetachedTimestampFile.deserialize(new Uint8Array(incompleteProof));
   } catch (error) {
     throw new ValidationError("Invalid .ots proof format", {
       /* v8 ignore next */
@@ -2222,7 +944,7 @@ async function orchestrateUpgrade(incompleteProof, _calendars, networkLayer, log
     }
   }
   const after = detached.serializeToBytes();
-  if (bytesEq(before, after)) {
+  if (bytesEqFast(before, after)) {
     throw new UpgradeError("No calendar has confirmed the timestamp yet (Bitcoin not yet mined)");
   }
   return Buffer.from(after);
@@ -2230,43 +952,82 @@ async function orchestrateUpgrade(incompleteProof, _calendars, networkLayer, log
 async function orchestrateVerify(proof, networkLayer, originalDataHash, logger, signal) {
   let detached;
   try {
-    detached = DetachedTimestampFile.deserialize(new Uint8Array(proof));
-  } catch {
-    return { valid: false, error: "Invalid .ots proof format" };
+    detached = import_core4.DetachedTimestampFile.deserialize(new Uint8Array(proof));
+  } catch (cause) {
+    throw new ValidationError("Invalid .ots proof format", {
+      cause: cause instanceof Error ? cause : void 0
+    });
   }
   if (originalDataHash !== void 0) {
     let expected;
     try {
       expected = validateHash(originalDataHash);
     } catch (err) {
-      return { valid: false, error: err instanceof Error ? err.message : "Invalid hash format" };
+      throw new ValidationError(
+        err instanceof Error ? err.message : "Invalid hash format",
+        { cause: err instanceof Error ? err : void 0 }
+      );
     }
-    if (!bytesEq(expected, detached.fileDigest())) {
-      return { valid: false, error: "File hash does not match proof" };
+    if (!timingSafeEq(expected, detached.fileDigest())) {
+      return { status: "invalid", reason: "File hash does not match proof \u2014 file may have been modified" };
     }
   }
-  const bitcoinAtts = detached.timestamp.allAttestations().filter(({ attestation }) => attestation.kind === "bitcoin");
+  const allBitcoin = detached.timestamp.allAttestations().filter(({ attestation }) => attestation.kind === "bitcoin");
+  const seenHeights = /* @__PURE__ */ new Set();
+  const deduped = allBitcoin.filter(({ attestation }) => {
+    if (attestation.kind !== "bitcoin") return false;
+    if (seenHeights.has(attestation.height)) {
+      logger?.debug(`Skipping duplicate Bitcoin attestation at height ${attestation.height}`);
+      return false;
+    }
+    seenHeights.add(attestation.height);
+    return true;
+  });
+  const bitcoinAtts = deduped.slice(0, MAX_BITCOIN_ATTESTATIONS);
+  if (deduped.length > MAX_BITCOIN_ATTESTATIONS) {
+    logger?.warn(
+      `Proof has ${deduped.length} unique Bitcoin attestations; verifying only the first ${MAX_BITCOIN_ATTESTATIONS}`
+    );
+  }
   if (bitcoinAtts.length === 0) {
     const hasLitecoin = detached.timestamp.allAttestations().some(({ attestation }) => attestation.kind === "litecoin");
-    if (hasLitecoin) {
-      return { valid: false, error: "Litecoin verification is not supported by this client" };
-    }
-    return { valid: false, error: "No Bitcoin attestation found (timestamp not yet confirmed)" };
+    return {
+      status: "pending",
+      reason: hasLitecoin ? "Litecoin-only attestation is not supported by this client" : "No Bitcoin attestation found \u2014 timestamp not yet confirmed"
+    };
   }
   const explorer = new EsploraClient(networkLayer);
-  let lastError = "";
+  let lastNetworkError;
+  let lastCryptoError;
   for (const { msg, attestation } of bitcoinAtts) {
     if (attestation.kind !== "bitcoin") continue;
     try {
-      const time = await verifyTimestampAttestation(Uint8Array.from(msg).reverse(), attestation, explorer, signal);
+      const blockTime = await verifyTimestampAttestation(
+        Uint8Array.from(msg).reverse(),
+        attestation,
+        explorer,
+        signal
+      );
       logger?.info(`Verified against Bitcoin block ${attestation.height}`);
-      return { valid: true, blockHeight: attestation.height, timestamp: time };
+      return { status: "verified", blockHeight: attestation.height, blockTime };
     } catch (err) {
-      lastError = err instanceof Error ? err.message : String(err);
-      logger?.warn(`Bitcoin attestation at height ${attestation.height} failed: ${lastError}`);
+      const message = err instanceof Error ? err.message : String(err);
+      if (err instanceof NetworkError || err instanceof EsploraResponseError) {
+        lastNetworkError = message;
+        logger?.warn(`Network error at block ${attestation.height}: ${message}`);
+      } else {
+        lastCryptoError = message;
+        logger?.warn(`Crypto verification failed at block ${attestation.height}: ${message}`);
+      }
     }
   }
-  return { valid: false, error: `Could not verify against the Bitcoin blockchain: ${lastError}` };
+  if (lastCryptoError !== void 0) {
+    return { status: "invalid", reason: `Cryptographic verification failed: ${lastCryptoError}` };
+  }
+  return {
+    status: "network_error",
+    reason: `Could not reach Bitcoin blockchain: ${lastNetworkError ?? "unknown error"}`
+  };
 }
 
 // src/client.ts
@@ -2276,6 +1037,7 @@ var OpenTimestampsClient = class {
   logger;
   globalSignal;
   minimumSuccessfulSubmissions;
+  allowPrivateCalendars;
   /**
    * Create a new OpenTimestamps client
    * 
@@ -2289,6 +1051,7 @@ var OpenTimestampsClient = class {
       this.calendars = options.calendars;
     }
     this.minimumSuccessfulSubmissions = options.minimumSuccessfulSubmissions ?? 2;
+    this.allowPrivateCalendars = options.allowPrivateCalendars ?? false;
     const resilienceConfig = {
       ...DEFAULT_RESILIENCE,
       ...options.resilience,
@@ -2307,7 +1070,8 @@ var OpenTimestampsClient = class {
     };
     this.logger = options.logger;
     this.globalSignal = options.signal;
-    this.networkLayer = options.networkLayer ?? new ResilientNetworkLayer(resilienceConfig, this.logger);
+    const internalOptions = options;
+    this.networkLayer = internalOptions._networkLayer ?? new ResilientNetworkLayer(resilienceConfig, this.logger);
     this.logger?.info(`OpenTimestamps client initialized with ${this.calendars.length} calendars`);
   }
   /**
@@ -2336,7 +1100,8 @@ var OpenTimestampsClient = class {
       this.networkLayer,
       this.logger,
       signal,
-      this.minimumSuccessfulSubmissions
+      this.minimumSuccessfulSubmissions,
+      this.allowPrivateCalendars
     );
   }
   /**
@@ -2421,6 +1186,10 @@ var OpenTimestampsClient = class {
   }
 };
 
+// src/index.ts
+var import_core5 = require("@otskit/core");
+var import_core6 = require("@otskit/core");
+
 // src/utils/hash.ts
 var import_crypto = require("crypto");
 var import_fs = require("fs");
@@ -2454,13 +1223,16 @@ function hashFile(path) {
   OpenTimestampsClientError,
   PUBLIC_ESPLORA_URL,
   ResilientNetworkLayer,
+  SizeLimitExceededError,
   StampError,
   Timestamp,
   UpgradeError,
   UrlWhitelist,
   ValidationError,
+  assertSafeCalendarUrl,
   hashBuffer,
   hashFile,
+  isVerified,
   verifyAgainstBlockheader,
   verifyTimestampAttestation
 });