@otskit/client 0.1.1 → 0.1.2

package/dist/index.js

@@ -392,16 +392,1453 @@ var ResilientNetworkLayer = class {
   }
 };
 
-// src/core/orchestration.ts
-import {
-  DetachedTimestampFile,
-  OpSHA256,
-  OpAppend,
-  makeMerkleTree
-} from "@otskit/core";
+// node_modules/.pnpm/@otskit+core@0.1.0/node_modules/@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/network/calendar.ts
-import { Timestamp, StreamDeserializationContext, bytesToHex } from "@otskit/core";
 var MAX_CALENDAR_RESPONSE_SIZE = 1e4;
 function assertCommitment(bytes) {
   if (!(bytes instanceof Uint8Array)) {
@@ -523,7 +1960,6 @@ var DEFAULT_AGGREGATORS = [
 ];
 
 // src/network/esplora.ts
-import { verifyAgainstBlockheader, VerificationError } from "@otskit/core";
 var PUBLIC_ESPLORA_URL = "https://blockstream.info/api";
 var MAX_ESPLORA_RESPONSE_SIZE = 1e5;
 var HEX64_RE = /^[0-9a-f]{64}$/i;
@@ -931,10 +2367,6 @@ var OpenTimestampsClient = class {
     this.networkLayer.resetAllCircuits();
   }
 };
-
-// src/index.ts
-import { DetachedTimestampFile as DetachedTimestampFile2, Timestamp as Timestamp2 } from "@otskit/core";
-import { verifyAgainstBlockheader as verifyAgainstBlockheader2 } from "@otskit/core";
 export {
   CalendarClient,
   CalendarResponseTooLargeError,
@@ -945,7 +2377,7 @@ export {
   DEFAULT_CALENDARS,
   DEFAULT_CALENDAR_WHITELIST,
   DEFAULT_RESILIENCE,
-  DetachedTimestampFile2 as DetachedTimestampFile,
+  DetachedTimestampFile,
   EsploraClient,
   EsploraResponseError,
   MAX_CALENDAR_RESPONSE_SIZE,
@@ -956,10 +2388,10 @@ export {
   PUBLIC_ESPLORA_URL,
   ResilientNetworkLayer,
   StampError,
-  Timestamp2 as Timestamp,
+  Timestamp,
   UpgradeError,
   UrlWhitelist,
   ValidationError,
-  verifyAgainstBlockheader2 as verifyAgainstBlockheader,
+  verifyAgainstBlockheader,
   verifyTimestampAttestation
 };