@otskit/client 0.3.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,
@@ -41,7 +41,7 @@ __export(index_exports, {
   ResilientNetworkLayer: () => ResilientNetworkLayer,
   SizeLimitExceededError: () => SizeLimitExceededError,
   StampError: () => StampError,
-  Timestamp: () => Timestamp,
+  Timestamp: () => import_core5.Timestamp,
   UpgradeError: () => UpgradeError,
   UrlWhitelist: () => UrlWhitelist,
   ValidationError: () => ValidationError,
@@ -49,19 +49,15 @@ __export(index_exports, {
   hashBuffer: () => hashBuffer,
   hashFile: () => hashFile,
   isVerified: () => isVerified,
-  verifyAgainstBlockheader: () => verifyAgainstBlockheader,
+  verifyAgainstBlockheader: () => import_core6.verifyAgainstBlockheader,
   verifyTimestampAttestation: () => verifyTimestampAttestation
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/types.ts
+var import_core = require("@otskit/core");
 var isVerified = (r) => r.status === "verified";
-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 DEFAULT_CALENDARS = [...import_core.DEFAULT_CALENDAR_URLS];
 var DEFAULT_RESILIENCE = {
   totalTimeoutMs: 3e4,
   connectTimeoutMs: 5e3,
@@ -489,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)) {
@@ -1975,7 +529,7 @@ var CalendarClient = class {
   /** 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 {
@@ -2001,8 +555,8 @@ 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;
   }
@@ -2075,24 +629,11 @@ var UrlWhitelist = class {
     return `UrlWhitelist([${[...this.#patterns.keys()].join(", ")}])`;
   }
 };
-var DEFAULT_CALENDAR_WHITELIST = new UrlWhitelist([
-  "https://*.calendar.opentimestamps.org",
-  // Peter Todd
-  "https://*.btc.calendar.opentimestamps.org",
-  // Peter Todd Bitcoin calendars
-  "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;
@@ -2183,11 +724,11 @@ var EsploraClient = class {
 };
 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
@@ -2334,10 +875,10 @@ async function orchestrateStamp(hash, calendars, networkLayer, logger, signal, m
   );
   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))
   );
@@ -2367,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 */
@@ -2411,7 +952,7 @@ async function orchestrateUpgrade(incompleteProof, _calendars, networkLayer, log
 async function orchestrateVerify(proof, networkLayer, originalDataHash, logger, signal) {
   let detached;
   try {
-    detached = DetachedTimestampFile.deserialize(new Uint8Array(proof));
+    detached = import_core4.DetachedTimestampFile.deserialize(new Uint8Array(proof));
   } catch (cause) {
     throw new ValidationError("Invalid .ots proof format", {
       cause: cause instanceof Error ? cause : void 0
@@ -2645,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");