@tangle-network/agent-eval 0.216.1 → 0.218.1

package/dist/ledger-core/lock-holder.js

@@ -0,0 +1,181 @@
+import { readFileSync, readlinkSync } from "node:fs";
+import { hostname } from "node:os";
+//#region src/ledger-core/lock-holder.ts
+/**
+* The one dead-owner rule: whether a lock's recorded holder is provably dead.
+*
+* A lock is safe to take over only when its holder is proved dead. A pid alone
+* proves nothing: the OS hands a dead holder's pid to a later process, and a
+* filesystem hands a removed lock's inode to the next lock. So a holder record
+* carries the pid's OS start token, the boot id, the pid namespace, the host,
+* and the identity of the lock it was written for, and the verdict is `dead`
+* only when those facts prove it. Anything the record or this host cannot
+* settle is `unknown`, and a caller keeps treating the lock as held.
+*
+* This module imports only Node built-ins, so lock owners in other packages can
+* import `@tangle-network/agent-eval/lock-holder` without loading the rest of
+* the package.
+*/
+function lockIdentity(stats) {
+	return {
+		dev: stats.dev.toString(),
+		ino: stats.ino.toString(),
+		birthtimeNs: stats.birthtimeNs.toString()
+	};
+}
+/**
+* The identity to record for `pid` on this host. The start token is read for
+* `pid` itself, so a lock taken on behalf of another live process records that
+* process. Fields the host cannot report are omitted, which leaves a later
+* verdict on the record `unknown` rather than wrong.
+*/
+function readLockHolderIdentity(pid = process.pid) {
+	const processStart = readProcessStart(pid);
+	const { bootId, pidNamespace } = ownHostIdentity();
+	return {
+		pid,
+		host: hostname(),
+		...processStart ? { processStart } : {},
+		...bootId ? { bootId } : {},
+		...pidNamespace ? { pidNamespace } : {}
+	};
+}
+/**
+* Decide whether `record`'s holder is dead, alive, or unknown.
+*
+* `currentLock` is the identity of the lock as it is now. `dead` needs a record
+* with a start token and a lock identity, written for this very lock (equal dev,
+* ino and a nonzero birthtime), on this host and pid namespace, and then a
+* rebooted host, a gone pid, or a pid whose start token changed. `alive` needs
+* the pid present with the recorded start token. Everything else is `unknown`,
+* so a live holder's lock is never taken.
+*/
+function lockHolderVerdict(record, currentLock) {
+	if (!record || !Number.isSafeInteger(record.pid) || record.pid <= 0) return unknown("unreadable record");
+	if (record.host !== hostname()) return unknown("other host");
+	if (!record.processStart || !record.lock) return unknown("incomplete record");
+	if (!currentLock || currentLock.birthtimeNs === "0" || currentLock.dev !== record.lock.dev || currentLock.ino !== record.lock.ino || currentLock.birthtimeNs !== record.lock.birthtimeNs) return unknown("lock changed");
+	const own = ownHostIdentity();
+	if (record.pidNamespace !== own.pidNamespace) return unknown("other pid namespace");
+	if (record.bootId === void 0 !== (own.bootId === void 0)) return unknown("boot id unavailable");
+	if (record.bootId !== own.bootId) return {
+		liveness: "dead",
+		reason: "host rebooted"
+	};
+	if (pidIsGone(record.pid)) return {
+		liveness: "dead",
+		reason: "pid gone"
+	};
+	const start = readProcessStart(record.pid);
+	if (start === void 0) return unknown("start token unavailable");
+	if (start !== record.processStart) return {
+		liveness: "dead",
+		reason: "pid reused"
+	};
+	return { liveness: "alive" };
+}
+/**
+* Read a holder record from parsed JSON. The required fields are `pid` and
+* `host`; an identity field that is missing or malformed is dropped, which
+* leaves the holder named but never provably dead.
+*/
+function parseLockHolderRecord(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const record = value;
+	if (!Number.isSafeInteger(record.pid) || record.pid <= 0) return void 0;
+	if (typeof record.host !== "string" || record.host.length === 0) return void 0;
+	const processStart = text(record.processStart);
+	const bootId = text(record.bootId);
+	const pidNamespace = text(record.pidNamespace);
+	const lock = parseLockIdentity(record.lock);
+	return {
+		pid: record.pid,
+		host: record.host,
+		...processStart ? { processStart } : {},
+		...bootId ? { bootId } : {},
+		...pidNamespace ? { pidNamespace } : {},
+		...lock ? { lock } : {}
+	};
+}
+function parseLockIdentity(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const lock = value;
+	if (!decimal(lock.dev) || !decimal(lock.ino) || !decimal(lock.birthtimeNs)) return void 0;
+	return {
+		dev: lock.dev,
+		ino: lock.ino,
+		birthtimeNs: lock.birthtimeNs
+	};
+}
+function unknown(reason) {
+	return {
+		liveness: "unknown",
+		reason
+	};
+}
+function text(field) {
+	return typeof field === "string" && field.length > 0 ? field : void 0;
+}
+function decimal(field) {
+	return typeof field === "string" && /^\d+$/u.test(field);
+}
+/** Only ESRCH proves a pid gone; EPERM means it exists under another user. */
+function pidIsGone(pid) {
+	try {
+		process.kill(pid, 0);
+		return false;
+	} catch (error) {
+		return error instanceof Error && "code" in error && error.code === "ESRCH";
+	}
+}
+let hostIdentity;
+function ownHostIdentity() {
+	if (hostIdentity) return hostIdentity;
+	const bootId = readOptional(() => readFileSync("/proc/sys/kernel/random/boot_id", "utf8").trim());
+	const pidNamespace = readOptional(() => readlinkSync("/proc/self/ns/pid"));
+	hostIdentity = {
+		...bootId ? { bootId } : {},
+		...pidNamespace ? { pidNamespace } : {}
+	};
+	return hostIdentity;
+}
+/**
+* The OS start token of a live pid: the same for a process's whole life and
+* different for every later holder of its pid. `undefined` when the host cannot
+* report one.
+*/
+function readProcessStart(pid) {
+	if (!Number.isSafeInteger(pid) || pid <= 0 || process.platform === "win32") return void 0;
+	if (process.platform === "linux") {
+		const stat = readOptional(() => readFileSync(`/proc/${pid}/stat`, "utf8"));
+		if (stat === void 0) return void 0;
+		const startTime = stat.slice(stat.lastIndexOf(")") + 1).trim().split(/\s+/u)[19];
+		return startTime !== void 0 && /^\d+$/u.test(startTime) ? startTime : void 0;
+	}
+	const childProcess = process.getBuiltinModule?.("node:child_process");
+	if (!childProcess) return void 0;
+	return readOptional(() => childProcess.execFileSync("ps", [
+		"-o",
+		"lstart=",
+		"-p",
+		String(pid)
+	], {
+		encoding: "utf8",
+		stdio: [
+			"ignore",
+			"pipe",
+			"ignore"
+		]
+	}).trim());
+}
+function readOptional(read) {
+	try {
+		return read() || void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { lockHolderVerdict, lockIdentity, parseLockHolderRecord, readLockHolderIdentity };
+
+//# sourceMappingURL=lock-holder.js.map

package/dist/ledger-core/lock-holder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock-holder.js","names":[],"sources":["../../src/ledger-core/lock-holder.ts"],"sourcesContent":["/**\n * The one dead-owner rule: whether a lock's recorded holder is provably dead.\n *\n * A lock is safe to take over only when its holder is proved dead. A pid alone\n * proves nothing: the OS hands a dead holder's pid to a later process, and a\n * filesystem hands a removed lock's inode to the next lock. So a holder record\n * carries the pid's OS start token, the boot id, the pid namespace, the host,\n * and the identity of the lock it was written for, and the verdict is `dead`\n * only when those facts prove it. Anything the record or this host cannot\n * settle is `unknown`, and a caller keeps treating the lock as held.\n *\n * This module imports only Node built-ins, so lock owners in other packages can\n * import `@tangle-network/agent-eval/lock-holder` without loading the rest of\n * the package.\n */\n\nimport { readFileSync, readlinkSync } from 'node:fs'\nimport { hostname } from 'node:os'\n\n/**\n * Identity of one lock path's inode, as decimal strings from a bigint `stat`.\n * ext4 hands a removed directory's inode to the next one at once (two\n * directories created 1.4 ms apart got the same inode on drew-gtr-pro), so dev\n * and ino alone can match a stale record to a live holder's new lock; the\n * nanosecond birthtime tells them apart.\n */\nexport interface LockIdentity {\n  readonly dev: string\n  readonly ino: string\n  readonly birthtimeNs: string\n}\n\n/** Who holds a lock: the process and the facts that tell it from a later holder of its pid. */\nexport interface LockHolderIdentity {\n  readonly pid: number\n  readonly host: string\n  /** OS start token of `pid`: Linux `/proc/<pid>/stat` starttime, elsewhere `ps` lstart. */\n  readonly processStart?: string\n  readonly bootId?: string\n  readonly pidNamespace?: string\n}\n\n/** A holder record as a lock owner writes it: the holder and the lock it was written for. */\nexport interface LockHolderRecord extends LockHolderIdentity {\n  readonly lock?: LockIdentity\n}\n\nexport type LockHolderDeathReason = 'pid gone' | 'pid reused' | 'host rebooted'\n\nexport type LockHolderUnknownReason =\n  | 'unreadable record'\n  | 'other host'\n  | 'incomplete record'\n  | 'lock changed'\n  | 'other pid namespace'\n  | 'boot id unavailable'\n  | 'start token unavailable'\n\nexport type LockHolderVerdict =\n  | { readonly liveness: 'dead'; readonly reason: LockHolderDeathReason }\n  | { readonly liveness: 'alive' }\n  | { readonly liveness: 'unknown'; readonly reason: LockHolderUnknownReason }\n\n/** Stat fields `lockIdentity` reads; pass `statSync(path, { bigint: true })` or its fstat/lstat. */\nexport interface LockIdentityStats {\n  readonly dev: bigint\n  readonly ino: bigint\n  readonly birthtimeNs: bigint\n}\n\nexport function lockIdentity(stats: LockIdentityStats): LockIdentity {\n  return {\n    dev: stats.dev.toString(),\n    ino: stats.ino.toString(),\n    birthtimeNs: stats.birthtimeNs.toString(),\n  }\n}\n\n/**\n * The identity to record for `pid` on this host. The start token is read for\n * `pid` itself, so a lock taken on behalf of another live process records that\n * process. Fields the host cannot report are omitted, which leaves a later\n * verdict on the record `unknown` rather than wrong.\n */\nexport function readLockHolderIdentity(pid: number = process.pid): LockHolderIdentity {\n  const processStart = readProcessStart(pid)\n  const { bootId, pidNamespace } = ownHostIdentity()\n  return {\n    pid,\n    host: hostname(),\n    ...(processStart ? { processStart } : {}),\n    ...(bootId ? { bootId } : {}),\n    ...(pidNamespace ? { pidNamespace } : {}),\n  }\n}\n\n/**\n * Decide whether `record`'s holder is dead, alive, or unknown.\n *\n * `currentLock` is the identity of the lock as it is now. `dead` needs a record\n * with a start token and a lock identity, written for this very lock (equal dev,\n * ino and a nonzero birthtime), on this host and pid namespace, and then a\n * rebooted host, a gone pid, or a pid whose start token changed. `alive` needs\n * the pid present with the recorded start token. Everything else is `unknown`,\n * so a live holder's lock is never taken.\n */\nexport function lockHolderVerdict(\n  record: LockHolderRecord | undefined,\n  currentLock: LockIdentity | undefined,\n): LockHolderVerdict {\n  if (!record || !Number.isSafeInteger(record.pid) || record.pid <= 0) {\n    return unknown('unreadable record')\n  }\n  if (record.host !== hostname()) return unknown('other host')\n  if (!record.processStart || !record.lock) return unknown('incomplete record')\n  if (\n    !currentLock ||\n    currentLock.birthtimeNs === '0' ||\n    currentLock.dev !== record.lock.dev ||\n    currentLock.ino !== record.lock.ino ||\n    currentLock.birthtimeNs !== record.lock.birthtimeNs\n  ) {\n    return unknown('lock changed')\n  }\n  const own = ownHostIdentity()\n  if (record.pidNamespace !== own.pidNamespace) return unknown('other pid namespace')\n  if ((record.bootId === undefined) !== (own.bootId === undefined)) {\n    return unknown('boot id unavailable')\n  }\n  if (record.bootId !== own.bootId) return { liveness: 'dead', reason: 'host rebooted' }\n  if (pidIsGone(record.pid)) return { liveness: 'dead', reason: 'pid gone' }\n  const start = readProcessStart(record.pid)\n  if (start === undefined) return unknown('start token unavailable')\n  if (start !== record.processStart) return { liveness: 'dead', reason: 'pid reused' }\n  return { liveness: 'alive' }\n}\n\n/**\n * Read a holder record from parsed JSON. The required fields are `pid` and\n * `host`; an identity field that is missing or malformed is dropped, which\n * leaves the holder named but never provably dead.\n */\nexport function parseLockHolderRecord(value: unknown): LockHolderRecord | undefined {\n  if (typeof value !== 'object' || value === null || Array.isArray(value)) return undefined\n  const record = value as Record<string, unknown>\n  if (!Number.isSafeInteger(record.pid) || (record.pid as number) <= 0) return undefined\n  if (typeof record.host !== 'string' || record.host.length === 0) return undefined\n  const processStart = text(record.processStart)\n  const bootId = text(record.bootId)\n  const pidNamespace = text(record.pidNamespace)\n  const lock = parseLockIdentity(record.lock)\n  return {\n    pid: record.pid as number,\n    host: record.host,\n    ...(processStart ? { processStart } : {}),\n    ...(bootId ? { bootId } : {}),\n    ...(pidNamespace ? { pidNamespace } : {}),\n    ...(lock ? { lock } : {}),\n  }\n}\n\nfunction parseLockIdentity(value: unknown): LockIdentity | undefined {\n  if (typeof value !== 'object' || value === null || Array.isArray(value)) return undefined\n  const lock = value as Record<string, unknown>\n  if (!decimal(lock.dev) || !decimal(lock.ino) || !decimal(lock.birthtimeNs)) return undefined\n  return { dev: lock.dev, ino: lock.ino, birthtimeNs: lock.birthtimeNs }\n}\n\nfunction unknown(reason: LockHolderUnknownReason): LockHolderVerdict {\n  return { liveness: 'unknown', reason }\n}\n\nfunction text(field: unknown): string | undefined {\n  return typeof field === 'string' && field.length > 0 ? field : undefined\n}\n\nfunction decimal(field: unknown): field is string {\n  return typeof field === 'string' && /^\\d+$/u.test(field)\n}\n\n/** Only ESRCH proves a pid gone; EPERM means it exists under another user. */\nfunction pidIsGone(pid: number): boolean {\n  try {\n    process.kill(pid, 0)\n    return false\n  } catch (error) {\n    return error instanceof Error && 'code' in error && error.code === 'ESRCH'\n  }\n}\n\ninterface HostIdentity {\n  readonly bootId?: string\n  readonly pidNamespace?: string\n}\n\nlet hostIdentity: HostIdentity | undefined\n\nfunction ownHostIdentity(): HostIdentity {\n  if (hostIdentity) return hostIdentity\n  const bootId = readOptional(() => readFileSync('/proc/sys/kernel/random/boot_id', 'utf8').trim())\n  const pidNamespace = readOptional(() => readlinkSync('/proc/self/ns/pid'))\n  hostIdentity = {\n    ...(bootId ? { bootId } : {}),\n    ...(pidNamespace ? { pidNamespace } : {}),\n  }\n  return hostIdentity\n}\n\n/**\n * The OS start token of a live pid: the same for a process's whole life and\n * different for every later holder of its pid. `undefined` when the host cannot\n * report one.\n */\nfunction readProcessStart(pid: number): string | undefined {\n  if (!Number.isSafeInteger(pid) || pid <= 0 || process.platform === 'win32') return undefined\n  if (process.platform === 'linux') {\n    const stat = readOptional(() => readFileSync(`/proc/${pid}/stat`, 'utf8'))\n    if (stat === undefined) return undefined\n    // The comm field is parenthesized and may hold spaces, so fields are counted after its close.\n    const startTime = stat\n      .slice(stat.lastIndexOf(')') + 1)\n      .trim()\n      .split(/\\s+/u)[19]\n    return startTime !== undefined && /^\\d+$/u.test(startTime) ? startTime : undefined\n  }\n  // `ps` lstart has 1 s resolution, so a pid reused within the same second reads\n  // as alive and keeps the lock: the safe direction. child_process is resolved\n  // on use so bundles that import this module never load it at startup.\n  const childProcess = process.getBuiltinModule?.('node:child_process') as\n    | typeof import('node:child_process')\n    | undefined\n  if (!childProcess) return undefined\n  return readOptional(() =>\n    childProcess\n      .execFileSync('ps', ['-o', 'lstart=', '-p', String(pid)], {\n        encoding: 'utf8',\n        stdio: ['ignore', 'pipe', 'ignore'],\n      })\n      .trim(),\n  )\n}\n\nfunction readOptional(read: () => string): string | undefined {\n  try {\n    return read() || undefined\n  } catch {\n    return undefined\n  }\n}\n"],"mappings":"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"}

package/dist/{ledger-core-Gq7yp8lP.js → ledger-core-CAxUdDk0.js}

@@ -1,6 +1,6 @@
-import { s as ValidationError } from "./errors-DVZiqS7K.js";
-import { t as LEDGER_HASH_PATTERN } from "./canonical-B2RqLofv.js";
-import "./journal-DfRz9kps.js";
+import { s as ValidationError } from "./errors-BcOs5MKW.js";
+import { t as LEDGER_HASH_PATTERN } from "./canonical-Dq2hOQ8L.js";
+import "./journal-C7om8Gum.js";
 import { sha256Bytes } from "@tangle-network/agent-interface";
 //#region src/ledger-core/merkle.ts
 /**
@@ -61,21 +61,6 @@ function merkleInclusionProof(leaves, leafIndex) {
 		path: path.map(toLedgerHash)
 	};
 }
-/**
-* Consistency proof that the first `oldSize` leaves are the tree of that size
-* (RFC 9162 §2.1.4.1). Sizes 0 and `leaves.length` need no path.
-*/
-function merkleConsistencyProof(leaves, oldSize) {
-	const nodes = decodeLeaves(leaves);
-	if (!Number.isSafeInteger(oldSize) || oldSize < 0 || oldSize > nodes.length) throw new ValidationError(`merkle old size ${oldSize} is outside a tree of ${nodes.length} leaves`);
-	const path = [];
-	if (oldSize > 0 && oldSize < nodes.length) subproof(nodes, oldSize, 0, nodes.length, true, path);
-	return {
-		oldSize,
-		newSize: nodes.length,
-		path: path.map(toLedgerHash)
-	};
-}
 /** Check that `leaf` is in the tree with `root` at the proof's index (RFC 9162 §2.1.3.2). */
 function verifyMerkleInclusion(leaf, proof, root) {
 	const { leafIndex, treeSize } = proof;
@@ -105,50 +90,6 @@ function verifyMerkleInclusion(leaf, proof, root) {
 	if (sn !== 0) return refused("proof path is shorter than the tree is deep");
 	return equal(r, rootBytes) ? { verified: true } : refused("leaf does not hash to the root");
 }
-/** Check that the tree with `newRoot` extends the tree with `oldRoot` (RFC 9162 §2.1.4.2). */
-function verifyMerkleConsistency(proof, oldRoot, newRoot) {
-	const { oldSize, newSize } = proof;
-	if (!isSize(oldSize) || !isSize(newSize) || oldSize > newSize) return refused(`old size ${oldSize} does not precede new size ${newSize}`);
-	const decoded = decodeAll([
-		oldRoot,
-		newRoot,
-		...proof.path
-	]);
-	if (decoded === void 0) return refused("proof carries a malformed hash");
-	const [oldBytes, newBytes, ...given] = decoded;
-	if (oldSize === 0 || oldSize === newSize) {
-		if (given.length !== 0) return refused("a trivial consistency proof must be empty");
-		if (oldSize === 0) return oldRoot === MERKLE_EMPTY_ROOT ? { verified: true } : refused("the empty tree has a different root");
-		return equal(oldBytes, newBytes) ? { verified: true } : refused("equal sizes with different roots");
-	}
-	const path = isPowerOfTwo(oldSize) ? [oldBytes, ...given] : given;
-	if (path.length === 0) return refused("consistency proof is empty");
-	let fn = oldSize - 1;
-	let sn = newSize - 1;
-	while (fn % 2 === 1) {
-		fn = Math.floor(fn / 2);
-		sn = Math.floor(sn / 2);
-	}
-	let fr = path[0];
-	let sr = fr;
-	for (const c of path.slice(1)) {
-		if (sn === 0) return refused("proof path is longer than the tree is deep");
-		if (fn % 2 === 1 || fn === sn) {
-			fr = node(c, fr);
-			sr = node(c, sr);
-			if (fn % 2 === 0) while (fn % 2 === 0 && fn !== 0) {
-				fn = Math.floor(fn / 2);
-				sn = Math.floor(sn / 2);
-			}
-		} else sr = node(sr, c);
-		fn = Math.floor(fn / 2);
-		sn = Math.floor(sn / 2);
-	}
-	if (sn !== 0) return refused("proof path is shorter than the tree is deep");
-	if (!equal(fr, oldBytes)) return refused("proof does not rebuild the old root");
-	if (!equal(sr, newBytes)) return refused("proof does not rebuild the new root");
-	return { verified: true };
-}
 function subtreeRoot(nodes, start, end) {
 	if (end - start === 1) return nodes[start];
 	const k = largestPowerOfTwoBelow(end - start);
@@ -165,20 +106,6 @@ function inclusionPath(nodes, index, start, end, path) {
 		path.push(subtreeRoot(nodes, start, start + k));
 	}
 }
-function subproof(nodes, oldSize, start, end, complete, path) {
-	if (end - start === oldSize) {
-		if (!complete) path.push(subtreeRoot(nodes, start, end));
-		return;
-	}
-	const k = largestPowerOfTwoBelow(end - start);
-	if (oldSize <= k) {
-		subproof(nodes, oldSize, start, start + k, complete, path);
-		path.push(subtreeRoot(nodes, start + k, end));
-	} else {
-		subproof(nodes, oldSize - k, start + k, end, false, path);
-		path.push(subtreeRoot(nodes, start, start + k));
-	}
-}
 function node(left, right) {
 	return fromHex(digest(NODE_PREFIX, left, right).slice(7));
 }
@@ -214,12 +141,6 @@ function largestPowerOfTwoBelow(n) {
 	while (k * 2 < n) k *= 2;
 	return k;
 }
-function isPowerOfTwo(n) {
-	if (n < 1) return false;
-	let m = n;
-	while (m % 2 === 0) m /= 2;
-	return m === 1;
-}
 function isSize(n) {
 	return Number.isSafeInteger(n) && n >= 0;
 }
@@ -243,6 +164,6 @@ function fromHex(hex) {
 	return bytes;
 }
 //#endregion
-export { merkleRoot as a, verifyMerkleInclusion as c, merkleLeafHash as i, merkleConsistencyProof as n, merkleSalt as o, merkleInclusionProof as r, verifyMerkleConsistency as s, MERKLE_EMPTY_ROOT as t };
+export { verifyMerkleInclusion as a, merkleSalt as i, merkleLeafHash as n, merkleRoot as r, merkleInclusionProof as t };
 
-//# sourceMappingURL=ledger-core-Gq7yp8lP.js.map
+//# sourceMappingURL=ledger-core-CAxUdDk0.js.map

package/dist/ledger-core-CAxUdDk0.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ledger-core-CAxUdDk0.js","names":[],"sources":["../src/ledger-core/merkle.ts"],"sourcesContent":["/**\n * Merkle proofs over an append-only list of leaves (RFC 9162 §2.1, the\n * Certificate Transparency tree).\n *\n * A hash chain proves a whole log against its head, but proving one entry means\n * replaying everything before it. This tree proves any one leaf against a root\n * with ⌈log₂ n⌉ hashes (inclusion), and proves that a larger tree only appended\n * to a smaller one (consistency). A verifier holding a root can therefore check\n * a single event, or that a later checkpoint extends an earlier one, without\n * reading the rest of the log.\n *\n * Leaves and interior nodes are domain-separated (0x00 and 0x01 prefixes), so a\n * leaf can never be presented as an interior node. Content that may later be\n * redacted takes a random 32-byte salt: a verifier then needs only the leaf's\n * hash, and short content cannot be guessed back from that hash. The salt must\n * be stored apart from anything that is shared after redaction.\n *\n * Builders refuse malformed input by throwing; verifiers never throw and return\n * a typed outcome, because a proof is external evidence and a bad one is a\n * finding, not a crash.\n */\nimport { sha256Bytes } from '@tangle-network/agent-interface'\nimport { ValidationError } from '../errors'\nimport { LEDGER_HASH_PATTERN, type LedgerHash } from './canonical'\n\n/** Proof that one leaf is at `leafIndex` in a tree of `treeSize` leaves. */\nexport interface MerkleInclusionProof {\n  readonly leafIndex: number\n  readonly treeSize: number\n  readonly path: readonly LedgerHash[]\n}\n\n/** Proof that the first `oldSize` leaves of a `newSize` tree are unchanged. */\nexport interface MerkleConsistencyProof {\n  readonly oldSize: number\n  readonly newSize: number\n  readonly path: readonly LedgerHash[]\n}\n\nexport type MerkleVerification =\n  | { readonly verified: true }\n  | { readonly verified: false; readonly reason: string }\n\nconst SALT_PATTERN = /^[a-f0-9]{64}$/\nconst LEAF_PREFIX = 0x00\nconst NODE_PREFIX = 0x01\nconst encoder = new TextEncoder()\n\n/** Root of the empty tree: SHA-256 of no bytes. */\nconst MERKLE_EMPTY_ROOT: LedgerHash = sha256Bytes(new Uint8Array(0)) as LedgerHash\n\n/** A fresh random salt for {@link merkleLeafHash}: 32 bytes as 64 lowercase hex characters. */\nexport function merkleSalt(): string {\n  return toHex(globalThis.crypto.getRandomValues(new Uint8Array(32)))\n}\n\n/**\n * Leaf hash of `content`: SHA-256(0x00 ‖ salt ‖ content). Without a salt this is\n * exactly the RFC 9162 leaf hash. Strings are hashed as UTF-8.\n */\nexport function merkleLeafHash(content: Uint8Array | string, salt?: string): LedgerHash {\n  const bytes = typeof content === 'string' ? encoder.encode(content) : content\n  if (salt === undefined) return digest(LEAF_PREFIX, bytes)\n  if (!SALT_PATTERN.test(salt)) {\n    throw new ValidationError('merkle salt must be 32 bytes as 64 lowercase hex characters')\n  }\n  return digest(LEAF_PREFIX, fromHex(salt), bytes)\n}\n\n/** Root over leaf hashes, in order. The empty list has {@link MERKLE_EMPTY_ROOT}. */\nexport function merkleRoot(leaves: readonly LedgerHash[]): LedgerHash {\n  const nodes = decodeLeaves(leaves)\n  return nodes.length === 0 ? MERKLE_EMPTY_ROOT : toLedgerHash(subtreeRoot(nodes, 0, nodes.length))\n}\n\n/** Inclusion proof for the leaf at `leafIndex` (RFC 9162 §2.1.3.1). */\nexport function merkleInclusionProof(\n  leaves: readonly LedgerHash[],\n  leafIndex: number,\n): MerkleInclusionProof {\n  const nodes = decodeLeaves(leaves)\n  if (!Number.isSafeInteger(leafIndex) || leafIndex < 0 || leafIndex >= nodes.length) {\n    throw new ValidationError(\n      `merkle leaf index ${leafIndex} is outside a tree of ${nodes.length} leaves`,\n    )\n  }\n  const path: Uint8Array[] = []\n  inclusionPath(nodes, leafIndex, 0, nodes.length, path)\n  return { leafIndex, treeSize: nodes.length, path: path.map(toLedgerHash) }\n}\n\n\n\n/** Check that `leaf` is in the tree with `root` at the proof's index (RFC 9162 §2.1.3.2). */\nexport function verifyMerkleInclusion(\n  leaf: LedgerHash,\n  proof: MerkleInclusionProof,\n  root: LedgerHash,\n): MerkleVerification {\n  const { leafIndex, treeSize } = proof\n  if (!isSize(treeSize) || !isSize(leafIndex) || leafIndex >= treeSize) {\n    return refused(`leaf index ${leafIndex} is outside a tree of ${treeSize} leaves`)\n  }\n  const decoded = decodeAll([leaf, root, ...proof.path])\n  if (decoded === undefined) return refused('proof carries a malformed hash')\n  const [leafBytes, rootBytes, ...path] = decoded as [Uint8Array, Uint8Array, ...Uint8Array[]]\n  let fn = leafIndex\n  let sn = treeSize - 1\n  let r = leafBytes\n  for (const p of path) {\n    if (sn === 0) return refused('proof path is longer than the tree is deep')\n    if (fn % 2 === 1 || fn === sn) {\n      r = node(p, r)\n      if (fn % 2 === 0) {\n        while (fn % 2 === 0 && fn !== 0) {\n          fn = Math.floor(fn / 2)\n          sn = Math.floor(sn / 2)\n        }\n      }\n    } else {\n      r = node(r, p)\n    }\n    fn = Math.floor(fn / 2)\n    sn = Math.floor(sn / 2)\n  }\n  if (sn !== 0) return refused('proof path is shorter than the tree is deep')\n  return equal(r, rootBytes) ? { verified: true } : refused('leaf does not hash to the root')\n}\n\n\n\nfunction subtreeRoot(nodes: readonly Uint8Array[], start: number, end: number): Uint8Array {\n  if (end - start === 1) return nodes[start] as Uint8Array\n  const k = largestPowerOfTwoBelow(end - start)\n  return node(subtreeRoot(nodes, start, start + k), subtreeRoot(nodes, start + k, end))\n}\n\nfunction inclusionPath(\n  nodes: readonly Uint8Array[],\n  index: number,\n  start: number,\n  end: number,\n  path: Uint8Array[],\n): void {\n  if (end - start === 1) return\n  const k = largestPowerOfTwoBelow(end - start)\n  if (index < start + k) {\n    inclusionPath(nodes, index, start, start + k, path)\n    path.push(subtreeRoot(nodes, start + k, end))\n  } else {\n    inclusionPath(nodes, index, start + k, end, path)\n    path.push(subtreeRoot(nodes, start, start + k))\n  }\n}\n\n\n\nfunction node(left: Uint8Array, right: Uint8Array): Uint8Array {\n  return fromHex(digest(NODE_PREFIX, left, right).slice('sha256:'.length))\n}\n\nfunction digest(prefix: number, ...parts: Uint8Array[]): LedgerHash {\n  const length = parts.reduce((total, part) => total + part.length, 1)\n  const bytes = new Uint8Array(length)\n  bytes[0] = prefix\n  let offset = 1\n  for (const part of parts) {\n    bytes.set(part, offset)\n    offset += part.length\n  }\n  return sha256Bytes(bytes) as LedgerHash\n}\n\nfunction decodeLeaves(leaves: readonly LedgerHash[]): Uint8Array[] {\n  const decoded = decodeAll(leaves)\n  if (decoded === undefined) {\n    throw new ValidationError('merkle leaves must be sha256:<64 lowercase hex> hashes')\n  }\n  return decoded\n}\n\nfunction decodeAll(hashes: readonly string[]): Uint8Array[] | undefined {\n  const out: Uint8Array[] = []\n  for (const hash of hashes) {\n    if (typeof hash !== 'string' || !LEDGER_HASH_PATTERN.test(hash)) return undefined\n    out.push(fromHex(hash.slice('sha256:'.length)))\n  }\n  return out\n}\n\nfunction toLedgerHash(bytes: Uint8Array): LedgerHash {\n  return `sha256:${toHex(bytes)}`\n}\n\nfunction largestPowerOfTwoBelow(n: number): number {\n  let k = 1\n  while (k * 2 < n) k *= 2\n  return k\n}\n\n\n\nfunction isSize(n: number): boolean {\n  return Number.isSafeInteger(n) && n >= 0\n}\n\nfunction equal(a: Uint8Array, b: Uint8Array): boolean {\n  if (a.length !== b.length) return false\n  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false\n  return true\n}\n\nfunction refused(reason: string): MerkleVerification {\n  return { verified: false, reason }\n}\n\nfunction toHex(bytes: Uint8Array): string {\n  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('')\n}\n\nfunction fromHex(hex: string): Uint8Array {\n  const bytes = new Uint8Array(hex.length / 2)\n  for (let i = 0; i < bytes.length; i++) bytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16)\n  return bytes\n}\n"],"mappings":"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"}