@cardanowall/sdk-ts 0.0.0

package/dist/merkle/index.js

@@ -0,0 +1,387 @@
+import { sha256 } from '@noble/hashes/sha2.js';
+import '@noble/hashes/blake2.js';
+import 'hash-wasm';
+import { encode, decode, cdeDecodeOptions } from 'cbor2';
+import { sortCoreDeterministic } from 'cbor2/sorts';
+
+// ../crypto-core/dist/hash.js
+function compareCt(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];
+  return diff === 0;
+}
+var MERKLE_ALG_ID = "rfc9162-sha256";
+var LEAF_PREFIX = 0;
+var NODE_PREFIX = 1;
+var DIGEST_LENGTH = 32;
+function validateLeaves(leaves, fnName) {
+  if (leaves.length === 0) {
+    throw new Error(`${fnName}: empty leaf list (n == 0 is forbidden by RFC 9162 \xA72.1.1)`);
+  }
+  for (let i = 0; i < leaves.length; i++) {
+    const leaf = leaves[i];
+    if (!(leaf instanceof Uint8Array) || leaf.length !== DIGEST_LENGTH) {
+      throw new Error(
+        `${fnName}: leaf[${i}] must be a Uint8Array(${DIGEST_LENGTH}); got length ${leaf instanceof Uint8Array ? leaf.length : "non-Uint8Array"}`
+      );
+    }
+  }
+}
+function merkleSha2256Root(leaves) {
+  validateLeaves(leaves, "merkleSha2256Root");
+  return mthRecursive(leaves, 0, leaves.length);
+}
+function merkleSha2256InclusionProof(leaves, index) {
+  validateLeaves(leaves, "merkleSha2256InclusionProof");
+  if (!Number.isInteger(index) || index < 0 || index >= leaves.length) {
+    throw new Error(
+      `merkleSha2256InclusionProof: index ${index} out of range [0, ${leaves.length})`
+    );
+  }
+  return auditPath(leaves, index, 0, leaves.length);
+}
+function merkleSha2256VerifyInclusion(leaf, index, treeSize, proof, root) {
+  if (!(leaf instanceof Uint8Array) || leaf.length !== DIGEST_LENGTH) return false;
+  if (!(root instanceof Uint8Array) || root.length !== DIGEST_LENGTH) return false;
+  if (!Number.isInteger(index) || !Number.isInteger(treeSize) || treeSize < 1 || index < 0 || index >= treeSize) {
+    return false;
+  }
+  for (let i = 0; i < proof.length; i++) {
+    const sibling = proof[i];
+    if (!(sibling instanceof Uint8Array) || sibling.length !== DIGEST_LENGTH) {
+      return false;
+    }
+  }
+  if (treeSize === 1) {
+    if (proof.length !== 0 || index !== 0) return false;
+    return compareCt(hashLeaf(leaf), root);
+  }
+  let h = hashLeaf(leaf);
+  let sn = index;
+  let fn = treeSize - 1;
+  for (let i = 0; i < proof.length; i++) {
+    if (fn === 0) return false;
+    const sibling = proof[i];
+    if ((sn & 1) === 1 || sn === fn) {
+      h = hashNode(sibling, h);
+      while ((sn & 1) === 0 && sn !== 0) {
+        sn >>>= 1;
+        fn >>>= 1;
+      }
+    } else {
+      h = hashNode(h, sibling);
+    }
+    sn >>>= 1;
+    fn >>>= 1;
+  }
+  if (fn !== 0) return false;
+  return compareCt(h, root);
+}
+function largestPow2Lt(n) {
+  let k = 1;
+  while (k * 2 < n) k *= 2;
+  return k;
+}
+function hashLeaf(d) {
+  const buf = new Uint8Array(1 + d.length);
+  buf[0] = LEAF_PREFIX;
+  buf.set(d, 1);
+  return sha256(buf);
+}
+function hashNode(left, right) {
+  const buf = new Uint8Array(1 + left.length + right.length);
+  buf[0] = NODE_PREFIX;
+  buf.set(left, 1);
+  buf.set(right, 1 + left.length);
+  return sha256(buf);
+}
+function mthRecursive(leaves, start, end) {
+  const n = end - start;
+  if (n === 1) {
+    return hashLeaf(leaves[start]);
+  }
+  const k = largestPow2Lt(n);
+  const left = mthRecursive(leaves, start, start + k);
+  const right = mthRecursive(leaves, start + k, end);
+  return hashNode(left, right);
+}
+function auditPath(leaves, i, start, end) {
+  const n = end - start;
+  if (n === 1) return [];
+  const k = largestPow2Lt(n);
+  if (i < k) {
+    const subPath2 = auditPath(leaves, i, start, start + k);
+    subPath2.push(mthRecursive(leaves, start + k, end));
+    return subPath2;
+  }
+  const subPath = auditPath(leaves, i - k, start + k, end);
+  subPath.push(mthRecursive(leaves, start, start + k));
+  return subPath;
+}
+var CanonicalCborError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "CanonicalCborError";
+    this.code = code;
+  }
+};
+function encodeCanonicalCbor(value) {
+  return encode(value, {
+    cde: true,
+    collapseBigInts: true,
+    rejectDuplicateKeys: true,
+    sortKeys: sortCoreDeterministic
+  });
+}
+function decodeCanonicalCbor(bytes) {
+  try {
+    return decode(bytes, {
+      ...cdeDecodeOptions,
+      rejectStreaming: true,
+      rejectDuplicateKeys: true,
+      // A CIP-309 record carries integers, byte/text strings, arrays, maps and
+      // `null` — and nothing else. Without these rejections the major-type-7
+      // surface leaks into the decoder: a float16/32/64 that happens to hold an
+      // integral value (e.g. 1.0) silently decodes to the integer 1 and passes
+      // a `z.literal(1)` / Number.isInteger schema check, so two byte strings
+      // that are NOT byte-identical canonicalise to the same record. That
+      // breaks the cross-implementation parity invariant (the Python twin
+      // already rejects non-integer `v` / `enc.scheme` outright). Reject the
+      // whole non-record surface — floats, negative zero, undefined, and
+      // non-{true,false,null} simple values — so any such input surfaces as
+      // MALFORMED_CBOR via mapDecodeError rather than decoding to a look-alike.
+      rejectFloats: true,
+      rejectNegativeZero: true,
+      rejectUndefined: true,
+      rejectSimple: true
+    });
+  } catch (cause) {
+    throw mapDecodeError(cause);
+  }
+}
+function mapDecodeError(cause) {
+  const message = cause instanceof Error ? cause.message : String(cause);
+  const lower = message.toLowerCase();
+  const isIndefinite = lower.includes("streaming") || lower.includes("indefinite");
+  const detail = isIndefinite ? `indefinite-length items are not permitted in canonical CBOR: ${message}` : message;
+  return new CanonicalCborError("MALFORMED_CBOR", `cbor decode failed: ${detail}`, { cause });
+}
+function compareCt2(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];
+  return diff === 0;
+}
+var LEAF_PREFIX2 = 0;
+var NODE_PREFIX2 = 1;
+var DIGEST_LENGTH2 = 32;
+function validateLeaves2(leaves, fnName) {
+  if (leaves.length === 0) {
+    throw new Error(`${fnName}: empty leaf list (n == 0 is forbidden by RFC 9162 \xA72.1.1)`);
+  }
+  for (let i = 0; i < leaves.length; i++) {
+    const leaf = leaves[i];
+    if (!(leaf instanceof Uint8Array) || leaf.length !== DIGEST_LENGTH2) {
+      throw new Error(
+        `${fnName}: leaf[${i}] must be a Uint8Array(${DIGEST_LENGTH2}); got length ${leaf instanceof Uint8Array ? leaf.length : "non-Uint8Array"}`
+      );
+    }
+  }
+}
+function merkleSha2256Root2(leaves) {
+  validateLeaves2(leaves, "merkleSha2256Root");
+  return mthRecursive2(leaves, 0, leaves.length);
+}
+function largestPow2Lt2(n) {
+  let k = 1;
+  while (k * 2 < n) k *= 2;
+  return k;
+}
+function hashLeaf2(d) {
+  const buf = new Uint8Array(1 + d.length);
+  buf[0] = LEAF_PREFIX2;
+  buf.set(d, 1);
+  return sha256(buf);
+}
+function hashNode2(left, right) {
+  const buf = new Uint8Array(1 + left.length + right.length);
+  buf[0] = NODE_PREFIX2;
+  buf.set(left, 1);
+  buf.set(right, 1 + left.length);
+  return sha256(buf);
+}
+function mthRecursive2(leaves, start, end) {
+  const n = end - start;
+  if (n === 1) {
+    return hashLeaf2(leaves[start]);
+  }
+  const k = largestPow2Lt2(n);
+  const left = mthRecursive2(leaves, start, start + k);
+  const right = mthRecursive2(leaves, start + k, end);
+  return hashNode2(left, right);
+}
+var LEAVES_LIST_FORMAT_V1 = "cardano-poe-merkle-leaves-v1";
+var TREE_ALG_RFC9162 = "rfc9162-sha256";
+var DIGEST_LENGTH22 = 32;
+var REGISTERED_FORMATS = /* @__PURE__ */ new Set([LEAVES_LIST_FORMAT_V1]);
+var MerkleLeavesListError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message ? `${code}: ${message}` : code);
+    this.code = code;
+    this.name = "MerkleLeavesListError";
+  }
+};
+function encodeLeavesList(args) {
+  if (!(args.root instanceof Uint8Array) || args.root.length !== DIGEST_LENGTH22) {
+    throw new MerkleLeavesListError(
+      "SCHEMA_MERKLE_LEAVES_MALFORMED",
+      `root must be a Uint8Array(${DIGEST_LENGTH22})`
+    );
+  }
+  if (args.leaves.length < 1) {
+    throw new MerkleLeavesListError(
+      "SCHEMA_MERKLE_LEAVES_MALFORMED",
+      "leaves array must be non-empty"
+    );
+  }
+  const leavesCopy = [];
+  for (let i = 0; i < args.leaves.length; i++) {
+    const leaf = args.leaves[i];
+    if (!(leaf instanceof Uint8Array) || leaf.length !== DIGEST_LENGTH22) {
+      throw new MerkleLeavesListError(
+        "SCHEMA_MERKLE_LEAVES_MALFORMED",
+        `leaves[${i}] must be a Uint8Array(${DIGEST_LENGTH22})`
+      );
+    }
+    leavesCopy.push(leaf);
+  }
+  if (args.leafAlg !== void 0 && typeof args.leafAlg !== "string") {
+    throw new MerkleLeavesListError(
+      "SCHEMA_MERKLE_LEAVES_MALFORMED",
+      "leaf_alg must be a string when present"
+    );
+  }
+  const map = {
+    format: LEAVES_LIST_FORMAT_V1,
+    tree_alg: TREE_ALG_RFC9162,
+    root: args.root,
+    leaves: leavesCopy,
+    leaf_count: leavesCopy.length
+  };
+  if (args.leafAlg !== void 0) {
+    map["leaf_alg"] = args.leafAlg;
+  }
+  return encodeCanonicalCbor(map);
+}
+function decodeLeavesList(bytes) {
+  const decoded = decodeCanonicalCbor(bytes);
+  if (typeof decoded !== "object" || decoded === null || Array.isArray(decoded)) {
+    throw new MerkleLeavesListError(
+      "SCHEMA_MERKLE_LEAVES_MALFORMED",
+      "leaves-list MUST be a CBOR map"
+    );
+  }
+  const m = decoded;
+  const format = m["format"];
+  if (typeof format !== "string") {
+    throw new MerkleLeavesListError(
+      "SCHEMA_MERKLE_LEAVES_MALFORMED",
+      "format must be a text string"
+    );
+  }
+  if (!REGISTERED_FORMATS.has(format)) {
+    throw new MerkleLeavesListError(
+      "SCHEMA_MERKLE_LEAVES_FORMAT_UNSUPPORTED",
+      `format '${format}' is not in the registered set`
+    );
+  }
+  const treeAlg = m["tree_alg"];
+  if (treeAlg !== TREE_ALG_RFC9162) {
+    throw new MerkleLeavesListError(
+      "SCHEMA_MERKLE_LEAVES_MALFORMED",
+      `tree_alg '${String(treeAlg)}' is not '${TREE_ALG_RFC9162}'`
+    );
+  }
+  const root = m["root"];
+  if (!(root instanceof Uint8Array) || root.length !== DIGEST_LENGTH22) {
+    throw new MerkleLeavesListError(
+      "SCHEMA_MERKLE_LEAVES_MALFORMED",
+      `root must be a ${DIGEST_LENGTH22}-byte byte string`
+    );
+  }
+  const leavesRaw = m["leaves"];
+  if (!Array.isArray(leavesRaw) || leavesRaw.length < 1) {
+    throw new MerkleLeavesListError(
+      "SCHEMA_MERKLE_LEAVES_MALFORMED",
+      "leaves must be a non-empty array"
+    );
+  }
+  const leaves = [];
+  for (let i = 0; i < leavesRaw.length; i++) {
+    const leaf = leavesRaw[i];
+    if (!(leaf instanceof Uint8Array) || leaf.length !== DIGEST_LENGTH22) {
+      throw new MerkleLeavesListError(
+        "SCHEMA_MERKLE_LEAVES_MALFORMED",
+        `leaves[${i}] must be a ${DIGEST_LENGTH22}-byte byte string`
+      );
+    }
+    leaves.push(leaf);
+  }
+  const leafCountRaw = m["leaf_count"];
+  let leafCount;
+  if (typeof leafCountRaw === "number" && Number.isInteger(leafCountRaw) && leafCountRaw >= 0) {
+    leafCount = leafCountRaw;
+  } else if (typeof leafCountRaw === "bigint" && leafCountRaw >= 0n) {
+    if (leafCountRaw > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new MerkleLeavesListError(
+        "SCHEMA_MERKLE_LEAVES_MALFORMED",
+        "leaf_count exceeds Number.MAX_SAFE_INTEGER"
+      );
+    }
+    leafCount = Number(leafCountRaw);
+  } else {
+    throw new MerkleLeavesListError(
+      "SCHEMA_MERKLE_LEAVES_MALFORMED",
+      "leaf_count must be a non-negative CBOR uint"
+    );
+  }
+  if (leaves.length !== leafCount) {
+    throw new MerkleLeavesListError(
+      "SCHEMA_MERKLE_LEAF_COUNT_MISMATCH",
+      `leaves.length (${leaves.length}) != leaf_count (${leafCount})`
+    );
+  }
+  let leafAlg;
+  if (m["leaf_alg"] !== void 0) {
+    if (typeof m["leaf_alg"] !== "string") {
+      throw new MerkleLeavesListError(
+        "SCHEMA_MERKLE_LEAVES_MALFORMED",
+        "leaf_alg must be a text string when present"
+      );
+    }
+    leafAlg = m["leaf_alg"];
+  }
+  const recomputed = merkleSha2256Root2(leaves);
+  if (!compareCt2(recomputed, root)) {
+    throw new MerkleLeavesListError(
+      "MERKLE_ROOT_MISMATCH",
+      "leaves recompute does not match declared root"
+    );
+  }
+  const out = {
+    format: LEAVES_LIST_FORMAT_V1,
+    treeAlg: TREE_ALG_RFC9162,
+    root,
+    leaves,
+    leafCount,
+    ...leafAlg !== void 0 ? { leafAlg } : {}
+  };
+  return out;
+}
+
+export { LEAVES_LIST_FORMAT_V1, MERKLE_ALG_ID, MerkleLeavesListError, decodeLeavesList, encodeLeavesList, merkleSha2256InclusionProof, merkleSha2256Root, merkleSha2256VerifyInclusion };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/merkle/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../crypto-core/src/util/compare-ct.ts","../../../crypto-core/src/hash/merkle-sha2-256.ts","../../../crypto-core/src/cbor/errors.ts","../../../crypto-core/src/cbor/canonical.ts","../../../crypto-core/src/merkle/leaves-list.ts"],"names":["sha256","subPath","compareCt","LEAF_PREFIX","NODE_PREFIX","DIGEST_LENGTH","validateLeaves","merkleSha2256Root","mthRecursive","largestPow2Lt","hashLeaf","hashNode"],"mappings":"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","file":"index.js","sourcesContent":["// Isomorphic constant-time byte-equality. crypto-core is browser-safe by\n// design, so we cannot import `node:crypto.timingSafeEqual` — webpack rejects\n// the `node:` scheme in the browser bundle. A pure-JS XOR loop is constant-time\n// for equal-length inputs; length mismatch is a deliberate early-return (the\n// API surface itself leaks length, same as node's timingSafeEqual which throws).\nexport function compareCt(a: Uint8Array, b: Uint8Array): boolean {\n  if (a.length !== b.length) return false;\n  let diff = 0;\n  // Lengths are equal and `i` stays in-bounds, so both indexes are always\n  // defined — no nullish guard is needed (and one would read as a guard for\n  // an impossible case).\n  for (let i = 0; i < a.length; i++) diff |= (a[i] as number) ^ (b[i] as number);\n  return diff === 0;\n}\n","// RFC 9162 §2.1.1 binary Merkle tree under SHA-256.\n// This implements the algorithm tier identified on the wire as the\n// `rfc9162-sha256` OPT-INFO; the record's `merkle[]` field carries the proof.\n//\n// Construction (RFC 9162 §2.1.1):\n//   - Single leaf:   MTH({d_0})     = SHA-256(0x00 || d_0)\n//   - Internal node: MTH(L)         = SHA-256(0x01 || MTH(L[0:k]) || MTH(L[k:n]))\n//     where k = largest power of 2 strictly less than n.\n//   - Empty trees (n == 0) are FORBIDDEN.\n//   - The 0x00 leaf / 0x01 internal prefixes prevent the CVE-2012-2459\n//     leaf-vs-internal collision family.\n\nimport { sha256 } from '@noble/hashes/sha2.js';\n\nimport { compareCt } from '../util/compare-ct';\n\nexport const MERKLE_ALG_ID = 'rfc9162-sha256' as const;\n\nconst LEAF_PREFIX = 0x00;\nconst NODE_PREFIX = 0x01;\nconst DIGEST_LENGTH = 32;\n\nfunction validateLeaves(leaves: ReadonlyArray<Uint8Array>, fnName: string): void {\n  if (leaves.length === 0) {\n    throw new Error(`${fnName}: empty leaf list (n == 0 is forbidden by RFC 9162 §2.1.1)`);\n  }\n  for (let i = 0; i < leaves.length; i++) {\n    const leaf = leaves[i];\n    if (!(leaf instanceof Uint8Array) || leaf.length !== DIGEST_LENGTH) {\n      throw new Error(\n        `${fnName}: leaf[${i}] must be a Uint8Array(${DIGEST_LENGTH}); got length ${\n          leaf instanceof Uint8Array ? leaf.length : 'non-Uint8Array'\n        }`,\n      );\n    }\n  }\n}\n\nexport function merkleSha2256Root(leaves: ReadonlyArray<Uint8Array>): Uint8Array {\n  validateLeaves(leaves, 'merkleSha2256Root');\n  return mthRecursive(leaves, 0, leaves.length);\n}\n\nexport function merkleSha2256InclusionProof(\n  leaves: ReadonlyArray<Uint8Array>,\n  index: number,\n): Uint8Array[] {\n  validateLeaves(leaves, 'merkleSha2256InclusionProof');\n  if (!Number.isInteger(index) || index < 0 || index >= leaves.length) {\n    throw new Error(\n      `merkleSha2256InclusionProof: index ${index} out of range [0, ${leaves.length})`,\n    );\n  }\n  return auditPath(leaves, index, 0, leaves.length);\n}\n\n/**\n * Verify an inclusion proof per RFC 9162 §2.1.3.2 (iterative form).\n *\n * `proof` is ordered leaf-to-root: `proof[0]` is the sibling at the leaf\n * level, `proof[m-1]` is the top-level sibling. The fold uses the\n * `sn`/`fn` tracking from RFC 9162: `sn` is the leaf index within the\n * current subtree, `fn` is (subtree_size - 1). At each step, `sn` odd\n * OR `sn == fn` means the current node is a right child (sibling on\n * the left); otherwise it is a left child (sibling on the right).\n * Both shift right by one each iteration. This handles non-power-of-2\n * sizes including the \"promote a lone right subtree\" cases.\n */\nexport function merkleSha2256VerifyInclusion(\n  leaf: Uint8Array,\n  index: number,\n  treeSize: number,\n  proof: ReadonlyArray<Uint8Array>,\n  root: Uint8Array,\n): boolean {\n  if (!(leaf instanceof Uint8Array) || leaf.length !== DIGEST_LENGTH) return false;\n  if (!(root instanceof Uint8Array) || root.length !== DIGEST_LENGTH) return false;\n  if (\n    !Number.isInteger(index) ||\n    !Number.isInteger(treeSize) ||\n    treeSize < 1 ||\n    index < 0 ||\n    index >= treeSize\n  ) {\n    return false;\n  }\n  for (let i = 0; i < proof.length; i++) {\n    const sibling = proof[i];\n    if (!(sibling instanceof Uint8Array) || sibling.length !== DIGEST_LENGTH) {\n      return false;\n    }\n  }\n\n  if (treeSize === 1) {\n    if (proof.length !== 0 || index !== 0) return false;\n    return compareCt(hashLeaf(leaf), root);\n  }\n\n  let h = hashLeaf(leaf);\n  let sn = index;\n  let fn = treeSize - 1;\n  for (let i = 0; i < proof.length; i++) {\n    if (fn === 0) return false;\n    const sibling = proof[i] as Uint8Array;\n    if ((sn & 1) === 1 || sn === fn) {\n      h = hashNode(sibling, h);\n      while ((sn & 1) === 0 && sn !== 0) {\n        sn >>>= 1;\n        fn >>>= 1;\n      }\n    } else {\n      h = hashNode(h, sibling);\n    }\n    sn >>>= 1;\n    fn >>>= 1;\n  }\n  if (fn !== 0) return false;\n  return compareCt(h, root);\n}\n\nfunction largestPow2Lt(n: number): number {\n  let k = 1;\n  while (k * 2 < n) k *= 2;\n  return k;\n}\n\nfunction hashLeaf(d: Uint8Array): Uint8Array {\n  const buf = new Uint8Array(1 + d.length);\n  buf[0] = LEAF_PREFIX;\n  buf.set(d, 1);\n  return sha256(buf);\n}\n\nfunction hashNode(left: Uint8Array, right: Uint8Array): Uint8Array {\n  const buf = new Uint8Array(1 + left.length + right.length);\n  buf[0] = NODE_PREFIX;\n  buf.set(left, 1);\n  buf.set(right, 1 + left.length);\n  return sha256(buf);\n}\n\nfunction mthRecursive(leaves: ReadonlyArray<Uint8Array>, start: number, end: number): Uint8Array {\n  const n = end - start;\n  if (n === 1) {\n    return hashLeaf(leaves[start] as Uint8Array);\n  }\n  const k = largestPow2Lt(n);\n  const left = mthRecursive(leaves, start, start + k);\n  const right = mthRecursive(leaves, start + k, end);\n  return hashNode(left, right);\n}\n\nfunction auditPath(\n  leaves: ReadonlyArray<Uint8Array>,\n  i: number,\n  start: number,\n  end: number,\n): Uint8Array[] {\n  const n = end - start;\n  if (n === 1) return [];\n  const k = largestPow2Lt(n);\n  if (i < k) {\n    const subPath = auditPath(leaves, i, start, start + k);\n    subPath.push(mthRecursive(leaves, start + k, end));\n    return subPath;\n  }\n  const subPath = auditPath(leaves, i - k, start + k, end);\n  subPath.push(mthRecursive(leaves, start, start + k));\n  return subPath;\n}\n","// Every canonical-CBOR decode violation collapses to the single public CIP-309\n// taxonomy code MALFORMED_CBOR: indefinite-length (streaming) items, duplicate\n// keys, unsorted keys, non-minimal integer encodings, and invalid UTF-8 in text\n// strings. The taxonomy intentionally has one code for all of these; the\n// specific cause survives in the human-readable error message, not as a\n// separate code.\nexport type CanonicalCborErrorCode = 'MALFORMED_CBOR';\n\nexport class CanonicalCborError extends Error {\n  readonly code: CanonicalCborErrorCode;\n\n  constructor(code: CanonicalCborErrorCode, message: string, options?: { cause?: unknown }) {\n    super(message, options);\n    this.name = 'CanonicalCborError';\n    this.code = code;\n  }\n}\n","import { cdeDecodeOptions, decode, encode } from 'cbor2';\nimport { sortCoreDeterministic } from 'cbor2/sorts';\n\nimport { CanonicalCborError } from './errors';\n\nexport type CanonicalCborValue =\n  | null\n  | boolean\n  | number\n  | bigint\n  | string\n  | Uint8Array\n  | readonly CanonicalCborValue[]\n  | { readonly [key: string]: CanonicalCborValue }\n  | ReadonlyMap<string | number, CanonicalCborValue>;\n\nexport function encodeCanonicalCbor(value: CanonicalCborValue): Uint8Array {\n  return encode(value, {\n    cde: true,\n    collapseBigInts: true,\n    rejectDuplicateKeys: true,\n    sortKeys: sortCoreDeterministic,\n  });\n}\n\nexport function decodeCanonicalCbor(bytes: Uint8Array): unknown {\n  try {\n    return decode(bytes, {\n      ...cdeDecodeOptions,\n      rejectStreaming: true,\n      rejectDuplicateKeys: true,\n      // A CIP-309 record carries integers, byte/text strings, arrays, maps and\n      // `null` — and nothing else. Without these rejections the major-type-7\n      // surface leaks into the decoder: a float16/32/64 that happens to hold an\n      // integral value (e.g. 1.0) silently decodes to the integer 1 and passes\n      // a `z.literal(1)` / Number.isInteger schema check, so two byte strings\n      // that are NOT byte-identical canonicalise to the same record. That\n      // breaks the cross-implementation parity invariant (the Python twin\n      // already rejects non-integer `v` / `enc.scheme` outright). Reject the\n      // whole non-record surface — floats, negative zero, undefined, and\n      // non-{true,false,null} simple values — so any such input surfaces as\n      // MALFORMED_CBOR via mapDecodeError rather than decoding to a look-alike.\n      rejectFloats: true,\n      rejectNegativeZero: true,\n      rejectUndefined: true,\n      rejectSimple: true,\n    });\n  } catch (cause) {\n    throw mapDecodeError(cause);\n  }\n}\n\nfunction mapDecodeError(cause: unknown): CanonicalCborError {\n  const message = cause instanceof Error ? cause.message : String(cause);\n  const lower = message.toLowerCase();\n  // Every canonical-decode violation collapses to the single public taxonomy\n  // code MALFORMED_CBOR: indefinite-length (streaming) items, duplicate keys,\n  // non-canonical (unsorted) key ordering, non-minimal integer encodings, and\n  // invalid UTF-8 in text strings. cbor2 raises the SAME \"Duplicate or out of\n  // order key\" message for both true duplicates AND distinct-but-unsorted keys,\n  // so the two are indistinguishable by message — and per the CIP-309 taxonomy\n  // both belong under MALFORMED_CBOR anyway. The specific cause survives in the\n  // human-readable message below; for indefinite-length we state it explicitly\n  // so the diagnostic is not lost when the code is collapsed.\n  const isIndefinite = lower.includes('streaming') || lower.includes('indefinite');\n  const detail = isIndefinite\n    ? `indefinite-length items are not permitted in canonical CBOR: ${message}`\n    : message;\n  return new CanonicalCborError('MALFORMED_CBOR', `cbor decode failed: ${detail}`, { cause });\n}\n","// Canonical-CBOR codec for the off-chain Merkle leaves-list artefact.\n// The on-chain `merkle[]` field binds to this file via `uris[]` / `leaf_count`;\n// the file itself carries the full leaf set. Canonical CBOR is RFC 8949 §4.2.1.\n//\n// CDDL:\n//\n//   leaves-list = {\n//     \"format\":     \"cardano-poe-merkle-leaves-v1\",\n//     \"tree_alg\":   \"rfc9162-sha256\",\n//     \"root\":       bytes .size 32,\n//     \"leaves\":     [ + bytes .size 32 ],\n//     \"leaf_count\": uint,\n//     ? \"leaf_alg\": tstr,\n//   }\n//\n// Canonical ordering is bytewise-lexicographic on encoded map keys (RFC 8949\n// §4.2.1) so the wire-key order is fixed by `cde:true` regardless of insertion\n// order: root (4B) < format (6B) < leaves (6B) < leaf_alg (8B) < tree_alg (8B)\n// < leaf_count (10B).\n\nimport { decodeCanonicalCbor, encodeCanonicalCbor } from '../cbor/canonical';\nimport { compareCt } from '../util/compare-ct';\nimport { merkleSha2256Root } from '../hash/merkle-sha2-256';\n\nexport const LEAVES_LIST_FORMAT_V1 = 'cardano-poe-merkle-leaves-v1' as const;\nconst TREE_ALG_RFC9162 = 'rfc9162-sha256' as const;\nconst DIGEST_LENGTH = 32;\nconst REGISTERED_FORMATS = new Set<string>([LEAVES_LIST_FORMAT_V1]);\n\nexport type MerkleLeavesListErrorCode =\n  | 'SCHEMA_MERKLE_LEAVES_FORMAT_UNSUPPORTED'\n  | 'SCHEMA_MERKLE_LEAVES_MALFORMED'\n  | 'SCHEMA_MERKLE_LEAF_COUNT_MISMATCH'\n  | 'MERKLE_ROOT_MISMATCH';\n\nexport class MerkleLeavesListError extends Error {\n  readonly code: MerkleLeavesListErrorCode;\n  constructor(code: MerkleLeavesListErrorCode, message?: string) {\n    super(message ? `${code}: ${message}` : code);\n    this.code = code;\n    this.name = 'MerkleLeavesListError';\n  }\n}\n\nexport interface EncodeLeavesListArgs {\n  readonly leaves: ReadonlyArray<Uint8Array>;\n  readonly root: Uint8Array;\n  readonly leafAlg?: string;\n}\n\nexport interface DecodedLeavesList {\n  readonly format: typeof LEAVES_LIST_FORMAT_V1;\n  readonly treeAlg: typeof TREE_ALG_RFC9162;\n  readonly root: Uint8Array;\n  readonly leaves: Uint8Array[];\n  readonly leafCount: number;\n  readonly leafAlg?: string;\n}\n\nexport function encodeLeavesList(args: EncodeLeavesListArgs): Uint8Array {\n  if (!(args.root instanceof Uint8Array) || args.root.length !== DIGEST_LENGTH) {\n    throw new MerkleLeavesListError(\n      'SCHEMA_MERKLE_LEAVES_MALFORMED',\n      `root must be a Uint8Array(${DIGEST_LENGTH})`,\n    );\n  }\n  if (args.leaves.length < 1) {\n    throw new MerkleLeavesListError(\n      'SCHEMA_MERKLE_LEAVES_MALFORMED',\n      'leaves array must be non-empty',\n    );\n  }\n  const leavesCopy: Uint8Array[] = [];\n  for (let i = 0; i < args.leaves.length; i++) {\n    const leaf = args.leaves[i];\n    if (!(leaf instanceof Uint8Array) || leaf.length !== DIGEST_LENGTH) {\n      throw new MerkleLeavesListError(\n        'SCHEMA_MERKLE_LEAVES_MALFORMED',\n        `leaves[${i}] must be a Uint8Array(${DIGEST_LENGTH})`,\n      );\n    }\n    leavesCopy.push(leaf);\n  }\n  if (args.leafAlg !== undefined && typeof args.leafAlg !== 'string') {\n    throw new MerkleLeavesListError(\n      'SCHEMA_MERKLE_LEAVES_MALFORMED',\n      'leaf_alg must be a string when present',\n    );\n  }\n  const map: Record<string, unknown> = {\n    format: LEAVES_LIST_FORMAT_V1,\n    tree_alg: TREE_ALG_RFC9162,\n    root: args.root,\n    leaves: leavesCopy,\n    leaf_count: leavesCopy.length,\n  };\n  if (args.leafAlg !== undefined) {\n    map['leaf_alg'] = args.leafAlg;\n  }\n  return encodeCanonicalCbor(map as never);\n}\n\nexport function decodeLeavesList(bytes: Uint8Array): DecodedLeavesList {\n  const decoded = decodeCanonicalCbor(bytes);\n  if (typeof decoded !== 'object' || decoded === null || Array.isArray(decoded)) {\n    throw new MerkleLeavesListError(\n      'SCHEMA_MERKLE_LEAVES_MALFORMED',\n      'leaves-list MUST be a CBOR map',\n    );\n  }\n  const m = decoded as Record<string, unknown>;\n\n  const format = m['format'];\n  if (typeof format !== 'string') {\n    throw new MerkleLeavesListError(\n      'SCHEMA_MERKLE_LEAVES_MALFORMED',\n      'format must be a text string',\n    );\n  }\n  if (!REGISTERED_FORMATS.has(format)) {\n    throw new MerkleLeavesListError(\n      'SCHEMA_MERKLE_LEAVES_FORMAT_UNSUPPORTED',\n      `format '${format}' is not in the registered set`,\n    );\n  }\n\n  const treeAlg = m['tree_alg'];\n  if (treeAlg !== TREE_ALG_RFC9162) {\n    throw new MerkleLeavesListError(\n      'SCHEMA_MERKLE_LEAVES_MALFORMED',\n      `tree_alg '${String(treeAlg)}' is not '${TREE_ALG_RFC9162}'`,\n    );\n  }\n\n  const root = m['root'];\n  if (!(root instanceof Uint8Array) || root.length !== DIGEST_LENGTH) {\n    throw new MerkleLeavesListError(\n      'SCHEMA_MERKLE_LEAVES_MALFORMED',\n      `root must be a ${DIGEST_LENGTH}-byte byte string`,\n    );\n  }\n\n  const leavesRaw = m['leaves'];\n  if (!Array.isArray(leavesRaw) || leavesRaw.length < 1) {\n    throw new MerkleLeavesListError(\n      'SCHEMA_MERKLE_LEAVES_MALFORMED',\n      'leaves must be a non-empty array',\n    );\n  }\n  const leaves: Uint8Array[] = [];\n  for (let i = 0; i < leavesRaw.length; i++) {\n    const leaf = leavesRaw[i];\n    if (!(leaf instanceof Uint8Array) || leaf.length !== DIGEST_LENGTH) {\n      throw new MerkleLeavesListError(\n        'SCHEMA_MERKLE_LEAVES_MALFORMED',\n        `leaves[${i}] must be a ${DIGEST_LENGTH}-byte byte string`,\n      );\n    }\n    leaves.push(leaf);\n  }\n\n  const leafCountRaw = m['leaf_count'];\n  let leafCount: number;\n  if (typeof leafCountRaw === 'number' && Number.isInteger(leafCountRaw) && leafCountRaw >= 0) {\n    leafCount = leafCountRaw;\n  } else if (typeof leafCountRaw === 'bigint' && leafCountRaw >= 0n) {\n    if (leafCountRaw > BigInt(Number.MAX_SAFE_INTEGER)) {\n      throw new MerkleLeavesListError(\n        'SCHEMA_MERKLE_LEAVES_MALFORMED',\n        'leaf_count exceeds Number.MAX_SAFE_INTEGER',\n      );\n    }\n    leafCount = Number(leafCountRaw);\n  } else {\n    throw new MerkleLeavesListError(\n      'SCHEMA_MERKLE_LEAVES_MALFORMED',\n      'leaf_count must be a non-negative CBOR uint',\n    );\n  }\n  if (leaves.length !== leafCount) {\n    throw new MerkleLeavesListError(\n      'SCHEMA_MERKLE_LEAF_COUNT_MISMATCH',\n      `leaves.length (${leaves.length}) != leaf_count (${leafCount})`,\n    );\n  }\n\n  let leafAlg: string | undefined;\n  if (m['leaf_alg'] !== undefined) {\n    if (typeof m['leaf_alg'] !== 'string') {\n      throw new MerkleLeavesListError(\n        'SCHEMA_MERKLE_LEAVES_MALFORMED',\n        'leaf_alg must be a text string when present',\n      );\n    }\n    leafAlg = m['leaf_alg'];\n  }\n\n  const recomputed = merkleSha2256Root(leaves);\n  if (!compareCt(recomputed, root)) {\n    throw new MerkleLeavesListError(\n      'MERKLE_ROOT_MISMATCH',\n      'leaves recompute does not match declared root',\n    );\n  }\n\n  const out: DecodedLeavesList = {\n    format: LEAVES_LIST_FORMAT_V1,\n    treeAlg: TREE_ALG_RFC9162,\n    root,\n    leaves,\n    leafCount,\n    ...(leafAlg !== undefined ? { leafAlg } : {}),\n  };\n  return out;\n}\n"]}

package/dist/types-B8Q3gW54.d.ts

@@ -0,0 +1,123 @@
+import { ValidationIssue, PoeRecord } from '@cardanowall/poe-standard';
+import { H as HttpCallRecord, F as FetchOutbound } from './fetch-outbound-BT5-NiYN.js';
+
+type Verdict = 'valid' | 'pending' | 'failed';
+type ExitCode = 0 | 1 | 2 | 3;
+type Profile = 'core' | 'signed' | 'sealed' | 'recipient-sealed';
+type Network = 'cardano:mainnet';
+declare const PROFILE_RANK: Readonly<Record<Profile, number>>;
+
+interface VerifyTxInput {
+    readonly txHash: string;
+    readonly profile?: Profile;
+    readonly cardanoGatewayChain?: ReadonlyArray<string>;
+    readonly blockfrostProjectId?: string;
+    readonly arweaveGatewayChain?: ReadonlyArray<string>;
+    readonly ipfsGatewayChain?: ReadonlyArray<string>;
+    readonly confirmationDepthThreshold?: number;
+    readonly denyHosts?: ReadonlyArray<string>;
+    readonly verifyMerkle?: boolean;
+    readonly decryption?: ReadonlyArray<{
+        readonly itemIndex: number;
+        readonly recipientSecretKey: Uint8Array;
+    } | {
+        readonly itemIndex: number;
+        readonly passphrase: string;
+    }>;
+    readonly ciphertextBytes?: Readonly<Record<number, Uint8Array>>;
+    readonly merkleLeaves?: Readonly<Record<number, Uint8Array>>;
+    readonly cardanoNetwork?: 'mainnet' | 'preprod';
+    readonly fetchOutbound?: FetchOutbound;
+}
+type SignatureVerdict = 'valid' | 'invalid' | 'unsupported' | 'unresolved';
+type SignatureFailureReason = 'MALFORMED_SIG_COSE_SIGN1' | 'SIGNATURE_UNSUPPORTED' | 'SIGNER_KEY_UNRESOLVED' | 'SIGNATURE_INVALID' | 'WALLET_ADDRESS_MISMATCH';
+type SignerType = 'in-signature-kid' | 'wallet-inline-key';
+interface VerifyRecordSignature {
+    readonly index: number;
+    readonly verdict: SignatureVerdict;
+    readonly signer_pub?: string;
+    readonly signer_type?: SignerType;
+    readonly reason?: SignatureFailureReason;
+}
+type DecryptionVerdict = 'decrypted' | 'wrong-key' | 'tampered-header' | 'tampered-ciphertext' | 'wrong-input-shape' | 'no-enc-envelope' | 'ciphertext-unavailable' | 'content-unavailable' | 'skipped' | 'kdf-failed';
+interface VerifyItemDecryption {
+    readonly item_index: number;
+    readonly verdict: DecryptionVerdict;
+    readonly plaintext_hash_ok?: boolean;
+    readonly reason?: string;
+}
+type ItemHashCheck = {
+    readonly item_index: number;
+    readonly alg: string;
+    readonly ok: boolean;
+};
+type MerkleVerdict = 'valid' | 'mismatch' | 'unavailable' | 'format-unsupported' | 'unsupported';
+interface VerifyMerkleCheck {
+    readonly merkle_index: number;
+    readonly alg: string;
+    readonly verdict: MerkleVerdict;
+    readonly root_recomputed?: Uint8Array;
+    readonly reason?: string;
+}
+interface VerifyUriCheck {
+    readonly item_index: number;
+    readonly uri: string;
+    readonly ok: boolean;
+    readonly reason?: string;
+}
+interface VerifyTxWitness {
+    readonly type: 'vkey';
+    readonly vkey: string;
+    readonly key_hash: string;
+    readonly signature_valid: boolean;
+}
+interface VerifyTxOutput {
+    readonly address: string;
+    readonly lovelace: string;
+}
+interface VerifyTxSummary {
+    readonly fee_lovelace: string;
+    readonly input_count: number;
+    readonly output_count: number;
+    readonly outputs: ReadonlyArray<VerifyTxOutput>;
+    readonly total_output_lovelace: string;
+    readonly script_witness_count: number;
+    readonly invalid_before?: number;
+    readonly invalid_hereafter?: number;
+    readonly required_signer_key_hashes?: ReadonlyArray<string>;
+    readonly network_id?: number;
+}
+interface VerifyReport {
+    readonly tx_hash: string;
+    readonly network: Network;
+    readonly verdict: Verdict;
+    readonly exit_code: ExitCode;
+    readonly profile: Profile;
+    readonly num_confirmations: number;
+    readonly confirmation_depth_threshold: number;
+    readonly block_time?: number;
+    readonly block_slot?: number;
+    readonly metadata_present: boolean;
+    readonly validation: {
+        readonly valid: boolean;
+        readonly issues?: ReadonlyArray<ValidationIssue>;
+        readonly warnings?: ReadonlyArray<ValidationIssue>;
+        readonly info?: ReadonlyArray<ValidationIssue>;
+    };
+    readonly record?: PoeRecord;
+    readonly record_signatures?: ReadonlyArray<VerifyRecordSignature>;
+    readonly tx_witnesses?: ReadonlyArray<VerifyTxWitness>;
+    readonly tx_summary?: VerifyTxSummary;
+    readonly metadata_labels?: ReadonlyArray<number>;
+    readonly item_hash_checks?: ReadonlyArray<ItemHashCheck>;
+    readonly item_decryptions?: ReadonlyArray<VerifyItemDecryption>;
+    readonly merkle_checks?: ReadonlyArray<VerifyMerkleCheck>;
+    readonly uri_checks?: ReadonlyArray<VerifyUriCheck>;
+    readonly supersedes_resolved?: {
+        readonly tx: string;
+        readonly exists: boolean;
+    };
+    readonly http_calls: ReadonlyArray<HttpCallRecord>;
+}
+
+export { type DecryptionVerdict as D, type ExitCode as E, type ItemHashCheck as I, type MerkleVerdict as M, type Network as N, PROFILE_RANK as P, type SignatureFailureReason as S, type Verdict as V, type Profile as a, type SignatureVerdict as b, type SignerType as c, type VerifyItemDecryption as d, type VerifyMerkleCheck as e, type VerifyRecordSignature as f, type VerifyReport as g, type VerifyTxInput as h, type VerifyTxOutput as i, type VerifyTxSummary as j, type VerifyTxWitness as k, type VerifyUriCheck as l };