@hashgraphonline/standards-sdk 0.1.168 → 0.1.170

package/dist/es/standards-sdk.es114.js

@@ -1,108 +1,267 @@
-import { z } from "zod";
-import { hcs26TopicTypeEnumSchema, HCS26_PROTOCOL, hcs26OperationEnumSchema } from "./standards-sdk.es112.js";
-const HCS26_DEFAULT_TTL_SECONDS = 86400;
-function toPositiveInt(value) {
-  if (!Number.isFinite(value)) {
-    throw new Error("Expected a finite number");
-  }
-  const intValue = Math.floor(value);
-  if (intValue <= 0) {
-    throw new Error("Expected a positive integer");
-  }
-  return intValue;
-}
-function buildHcs26TopicMemo(input) {
-  const indexed = input.indexed ?? true;
-  const ttlSeconds = toPositiveInt(
-    input.ttlSeconds ?? HCS26_DEFAULT_TTL_SECONDS
+import { createHash } from "crypto";
+import { hcs27ConsistencyProofSchema, hcs27InclusionProofSchema } from "./standards-sdk.es112.js";
+function normalizeJsonValue(value) {
+  if (value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
+    if (typeof value === "number" && !Number.isFinite(value)) {
+      throw new Error("JSON numbers must be finite");
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return Array.from(
+      value,
+      (item) => item === void 0 ? null : normalizeJsonValue(item)
+    );
+  }
+  if (typeof value === "object") {
+    const toJSON = value.toJSON;
+    if (typeof toJSON === "function") {
+      return normalizeJsonValue(toJSON.call(value));
+    }
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+      if (item !== void 0) {
+        result[key] = normalizeJsonValue(item);
+      }
+    }
+    return result;
+  }
+  throw new Error(`Unsupported JSON value type: ${typeof value}`);
+}
+function formatNumber(value) {
+  if (Object.is(value, -0)) {
+    return "0";
+  }
+  return value.toString();
+}
+function decodeBase64(value, fieldName) {
+  try {
+    if (!value) {
+      throw new Error("empty base64");
+    }
+    const decoded = Buffer.from(value, "base64");
+    if (decoded.toString("base64") !== value) {
+      throw new Error("non-canonical base64");
+    }
+    return decoded;
+  } catch {
+    throw new Error(`${fieldName} must be valid base64`);
+  }
+}
+function writeCanonicalJson(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number") {
+    return formatNumber(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => writeCanonicalJson(item)).join(",")}]`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value).sort(
+      ([left], [right]) => left < right ? -1 : left > right ? 1 : 0
+    );
+    return `{${entries.map(
+      ([key, item]) => `${JSON.stringify(key)}:${writeCanonicalJson(item)}`
+    ).join(",")}}`;
+  }
+  throw new Error(`Unsupported JSON value type: ${typeof value}`);
+}
+function parseTreeSize(value) {
+  return typeof value === "number" ? BigInt(value) : BigInt(value);
+}
+function leastSignificantBit(value) {
+  return value & 1n;
+}
+function isExactPowerOfTwo(value) {
+  return value !== 0n && (value & value - 1n) === 0n;
+}
+function largestPowerOfTwoLessThan(value) {
+  if (value <= 1) {
+    return 0;
+  }
+  let result = 1;
+  while (result << 1 < value) {
+    result <<= 1;
+  }
+  return result;
+}
+function canonicalizeHCS27Json(value) {
+  const normalized = normalizeJsonValue(value);
+  return Buffer.from(writeCanonicalJson(normalized), "utf8");
+}
+function emptyHCS27Root() {
+  return createHash("sha256").update(Buffer.alloc(0)).digest();
+}
+function hashHCS27Leaf(canonicalEntry) {
+  return createHash("sha256").update(Buffer.from([0])).update(Buffer.from(canonicalEntry)).digest();
+}
+function hashHCS27Node(left, right) {
+  return createHash("sha256").update(Buffer.from([1])).update(Buffer.from(left)).update(Buffer.from(right)).digest();
+}
+function merkleRootFromCanonicalEntries(entries) {
+  if (entries.length === 0) {
+    return emptyHCS27Root();
+  }
+  if (entries.length === 1) {
+    return hashHCS27Leaf(entries[0]);
+  }
+  const split = largestPowerOfTwoLessThan(entries.length);
+  const left = merkleRootFromCanonicalEntries(entries.slice(0, split));
+  const right = merkleRootFromCanonicalEntries(entries.slice(split));
+  return hashHCS27Node(left, right);
+}
+function merkleRootFromEntries(entries) {
+  const canonicalEntries = entries.map((entry) => canonicalizeHCS27Json(entry));
+  return merkleRootFromCanonicalEntries(canonicalEntries);
+}
+function leafHashHexFromEntry(entry) {
+  return hashHCS27Leaf(canonicalizeHCS27Json(entry)).toString("hex");
+}
+function verifyInclusionProof(params) {
+  let leafIndex;
+  let treeSize;
+  let leafHashHex;
+  let path;
+  let expectedRootB64;
+  if ("leafHash" in params) {
+    const proof = hcs27InclusionProofSchema.parse(params);
+    leafIndex = BigInt(proof.leafIndex);
+    treeSize = BigInt(proof.treeSize);
+    leafHashHex = proof.leafHash;
+    path = proof.path;
+    expectedRootB64 = proof.rootHash;
+  } else {
+    leafIndex = parseTreeSize(params.leafIndex);
+    treeSize = parseTreeSize(params.treeSize);
+    leafHashHex = params.leafHashHex;
+    path = params.path;
+    expectedRootB64 = params.expectedRootB64;
+  }
+  if (treeSize <= 0n) {
+    throw new Error("treeSize must be greater than zero for inclusion proofs");
+  }
+  if (leafIndex < 0n || leafIndex >= treeSize) {
+    throw new Error("leafIndex must be less than treeSize");
+  }
+  if (!/^(?:[0-9a-f]{2})+$/i.test(leafHashHex.trim())) {
+    throw new Error("leafHash must be valid hex");
+  }
+  let current;
+  try {
+    current = Buffer.from(leafHashHex.trim(), "hex");
+  } catch {
+    throw new Error("leafHash must be valid hex");
+  }
+  let fn = leafIndex;
+  let sn = treeSize - 1n;
+  for (const [index, node] of path.entries()) {
+    if (sn === 0n) {
+      return false;
+    }
+    const sibling = decodeBase64(node, `path[${index}]`);
+    if (leastSignificantBit(fn) === 1n || fn === sn) {
+      current = hashHCS27Node(sibling, current);
+      if (leastSignificantBit(fn) === 0n) {
+        while (leastSignificantBit(fn) === 0n && fn !== 0n) {
+          fn /= 2n;
+          sn /= 2n;
+        }
+      }
+    } else {
+      current = hashHCS27Node(current, sibling);
+    }
+    fn /= 2n;
+    sn /= 2n;
+  }
+  return sn === 0n && current.toString("base64") === expectedRootB64;
+}
+function verifyConsistencyProof(params) {
+  let oldTreeSize;
+  let newTreeSize;
+  let oldRootB64;
+  let newRootB64;
+  let consistencyPath;
+  if ("oldRootHash" in params) {
+    const proof = hcs27ConsistencyProofSchema.parse(params);
+    oldTreeSize = BigInt(proof.oldTreeSize);
+    newTreeSize = BigInt(proof.newTreeSize);
+    oldRootB64 = proof.oldRootHash;
+    newRootB64 = proof.newRootHash;
+    consistencyPath = proof.consistencyPath;
+  } else {
+    oldTreeSize = parseTreeSize(params.oldTreeSize);
+    newTreeSize = parseTreeSize(params.newTreeSize);
+    oldRootB64 = params.oldRootB64;
+    newRootB64 = params.newRootB64;
+    consistencyPath = params.consistencyPath;
+  }
+  if (oldTreeSize < 0n || newTreeSize < 0n) {
+    throw new Error("tree sizes must be non-negative");
+  }
+  if (oldTreeSize === 0n) {
+    return true;
+  }
+  if (oldTreeSize === newTreeSize) {
+    decodeBase64(oldRootB64, "oldRootHash");
+    decodeBase64(newRootB64, "newRootHash");
+    return oldRootB64 === newRootB64 && consistencyPath.length === 0;
+  }
+  if (oldTreeSize > newTreeSize || consistencyPath.length === 0) {
+    return false;
+  }
+  const path = consistencyPath.map(
+    (node, index) => decodeBase64(node, `consistencyPath[${index}]`)
   );
-  const topicType = hcs26TopicTypeEnumSchema.parse(input.topicType);
-  const indexedSegment = indexed ? "0" : "1";
-  return `${HCS26_PROTOCOL}:${indexedSegment}:${ttlSeconds}:${topicType}`;
-}
-function parseHcs26TopicMemo(memoRaw) {
-  const memo = memoRaw.trim();
-  if (!memo) {
-    return null;
-  }
-  const match = memo.match(/^hcs-26:(\d+):(\d+):(\d+)$/);
-  if (!match) {
-    return null;
-  }
-  const indexedSegment = Number(match[1]);
-  const ttlSeconds = Number(match[2]);
-  const topicType = Number(match[3]);
-  if (![indexedSegment, ttlSeconds, topicType].every(Number.isFinite)) {
-    return null;
-  }
-  const parsedTopicType = hcs26TopicTypeEnumSchema.safeParse(topicType);
-  if (!parsedTopicType.success) {
-    return null;
-  }
-  if (indexedSegment !== 0 && indexedSegment !== 1) {
-    return null;
-  }
-  return {
-    protocol: HCS26_PROTOCOL,
-    indexed: indexedSegment === 0,
-    ttlSeconds,
-    topicType: parsedTopicType.data
-  };
-}
-function buildHcs26TransactionMemo(input) {
-  const operation = hcs26OperationEnumSchema.parse(input.operation);
-  const topicType = hcs26TopicTypeEnumSchema.parse(input.topicType);
-  return `${HCS26_PROTOCOL}:op:${operation}:${topicType}`;
-}
-function parseHcs26TransactionMemo(memoRaw) {
-  const memo = memoRaw.trim();
-  if (!memo) {
-    return null;
-  }
-  const match = memo.match(/^hcs-26:op:(\d+):(\d+)$/);
-  if (!match) {
-    return null;
-  }
-  const operation = Number(match[1]);
-  const topicType = Number(match[2]);
-  if (![operation, topicType].every(Number.isFinite)) {
-    return null;
-  }
-  const parsedOperation = hcs26OperationEnumSchema.safeParse(operation);
-  if (!parsedOperation.success) {
-    return null;
-  }
-  const parsedTopicType = hcs26TopicTypeEnumSchema.safeParse(topicType);
-  if (!parsedTopicType.success) {
-    return null;
-  }
-  return {
-    protocol: HCS26_PROTOCOL,
-    operation: parsedOperation.data,
-    topicType: parsedTopicType.data
-  };
-}
-const hcs26TopicMemoSchema = z.string().transform((value) => {
-  const parsed = parseHcs26TopicMemo(value);
-  if (!parsed) {
-    throw new Error("Invalid HCS-26 topic memo");
-  }
-  return parsed;
-});
-const hcs26TransactionMemoSchema = z.string().transform((value) => {
-  const parsed = parseHcs26TransactionMemo(value);
-  if (!parsed) {
-    throw new Error("Invalid HCS-26 transaction memo");
-  }
-  return parsed;
-});
+  if (isExactPowerOfTwo(oldTreeSize)) {
+    path.unshift(decodeBase64(oldRootB64, "oldRootHash"));
+  }
+  let fn = oldTreeSize - 1n;
+  let sn = newTreeSize - 1n;
+  while (leastSignificantBit(fn) === 1n) {
+    fn /= 2n;
+    sn /= 2n;
+  }
+  const firstHash = Buffer.from(path[0]);
+  let fr = Buffer.from(firstHash);
+  let sr = Buffer.from(firstHash);
+  for (const nodeHash of path.slice(1)) {
+    if (sn === 0n) {
+      return false;
+    }
+    if (leastSignificantBit(fn) === 1n || fn === sn) {
+      fr = hashHCS27Node(nodeHash, fr);
+      sr = hashHCS27Node(nodeHash, sr);
+      if (leastSignificantBit(fn) === 0n) {
+        while (leastSignificantBit(fn) === 0n && fn !== 0n) {
+          fn /= 2n;
+          sn /= 2n;
+        }
+      }
+    } else {
+      sr = hashHCS27Node(sr, nodeHash);
+    }
+    fn /= 2n;
+    sn /= 2n;
+  }
+  return sn === 0n && Buffer.from(fr).toString("base64") === oldRootB64 && Buffer.from(sr).toString("base64") === newRootB64;
+}
 export {
-  HCS26_DEFAULT_TTL_SECONDS,
-  buildHcs26TopicMemo,
-  buildHcs26TransactionMemo,
-  hcs26TopicMemoSchema,
-  hcs26TransactionMemoSchema,
-  parseHcs26TopicMemo,
-  parseHcs26TransactionMemo
+  canonicalizeHCS27Json,
+  emptyHCS27Root,
+  hashHCS27Leaf,
+  hashHCS27Node,
+  leafHashHexFromEntry,
+  merkleRootFromCanonicalEntries,
+  merkleRootFromEntries,
+  verifyConsistencyProof,
+  verifyInclusionProof
 };
 //# sourceMappingURL=standards-sdk.es114.js.map

package/dist/es/standards-sdk.es114.js.map

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es114.js","sources":["../../src/hcs-26/memos.ts"],"sourcesContent":["import { z } from 'zod';\nimport {\n  HCS26_PROTOCOL,\n  hcs26OperationEnumSchema,\n  hcs26TopicTypeEnumSchema,\n  type Hcs26OperationEnum,\n  type Hcs26TopicTypeEnum,\n} from './types';\n\nexport type Hcs26TopicMemo = {\n  protocol: typeof HCS26_PROTOCOL;\n  indexed: boolean;\n  ttlSeconds: number;\n  topicType: Hcs26TopicTypeEnum;\n};\n\nexport const HCS26_DEFAULT_TTL_SECONDS = 86400;\n\nfunction toPositiveInt(value: number): number {\n  if (!Number.isFinite(value)) {\n    throw new Error('Expected a finite number');\n  }\n  const intValue = Math.floor(value);\n  if (intValue <= 0) {\n    throw new Error('Expected a positive integer');\n  }\n  return intValue;\n}\n\nexport function buildHcs26TopicMemo(input: {\n  indexed?: boolean;\n  ttlSeconds?: number;\n  topicType: Hcs26TopicTypeEnum;\n}): string {\n  const indexed = input.indexed ?? true;\n  const ttlSeconds = toPositiveInt(\n    input.ttlSeconds ?? HCS26_DEFAULT_TTL_SECONDS,\n  );\n  const topicType = hcs26TopicTypeEnumSchema.parse(input.topicType);\n\n  // HCS-2 memo convention: indexed topics use \"0\" in the second segment.\n  const indexedSegment = indexed ? '0' : '1';\n  return `${HCS26_PROTOCOL}:${indexedSegment}:${ttlSeconds}:${topicType}`;\n}\n\nexport function parseHcs26TopicMemo(memoRaw: string): Hcs26TopicMemo | null {\n  const memo = memoRaw.trim();\n  if (!memo) {\n    return null;\n  }\n\n  const match = memo.match(/^hcs-26:(\\d+):(\\d+):(\\d+)$/);\n  if (!match) {\n    return null;\n  }\n\n  const indexedSegment = Number(match[1]);\n  const ttlSeconds = Number(match[2]);\n  const topicType = Number(match[3]);\n\n  if (![indexedSegment, ttlSeconds, topicType].every(Number.isFinite)) {\n    return null;\n  }\n\n  const parsedTopicType = hcs26TopicTypeEnumSchema.safeParse(topicType);\n  if (!parsedTopicType.success) {\n    return null;\n  }\n\n  if (indexedSegment !== 0 && indexedSegment !== 1) {\n    return null;\n  }\n\n  return {\n    protocol: HCS26_PROTOCOL,\n    indexed: indexedSegment === 0,\n    ttlSeconds,\n    topicType: parsedTopicType.data,\n  };\n}\n\nexport function buildHcs26TransactionMemo(input: {\n  operation: Hcs26OperationEnum;\n  topicType: Hcs26TopicTypeEnum;\n}): string {\n  const operation = hcs26OperationEnumSchema.parse(input.operation);\n  const topicType = hcs26TopicTypeEnumSchema.parse(input.topicType);\n  return `${HCS26_PROTOCOL}:op:${operation}:${topicType}`;\n}\n\nexport type Hcs26TransactionMemo = {\n  protocol: typeof HCS26_PROTOCOL;\n  operation: Hcs26OperationEnum;\n  topicType: Hcs26TopicTypeEnum;\n};\n\nexport function parseHcs26TransactionMemo(\n  memoRaw: string,\n): Hcs26TransactionMemo | null {\n  const memo = memoRaw.trim();\n  if (!memo) {\n    return null;\n  }\n\n  const match = memo.match(/^hcs-26:op:(\\d+):(\\d+)$/);\n  if (!match) {\n    return null;\n  }\n\n  const operation = Number(match[1]);\n  const topicType = Number(match[2]);\n  if (![operation, topicType].every(Number.isFinite)) {\n    return null;\n  }\n\n  const parsedOperation = hcs26OperationEnumSchema.safeParse(operation);\n  if (!parsedOperation.success) {\n    return null;\n  }\n  const parsedTopicType = hcs26TopicTypeEnumSchema.safeParse(topicType);\n  if (!parsedTopicType.success) {\n    return null;\n  }\n\n  return {\n    protocol: HCS26_PROTOCOL,\n    operation: parsedOperation.data,\n    topicType: parsedTopicType.data,\n  };\n}\n\nexport const hcs26TopicMemoSchema = z.string().transform(value => {\n  const parsed = parseHcs26TopicMemo(value);\n  if (!parsed) {\n    throw new Error('Invalid HCS-26 topic memo');\n  }\n  return parsed;\n});\n\nexport const hcs26TransactionMemoSchema = z.string().transform(value => {\n  const parsed = parseHcs26TransactionMemo(value);\n  if (!parsed) {\n    throw new Error('Invalid HCS-26 transaction memo');\n  }\n  return parsed;\n});\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"standards-sdk.es114.js","sources":["../../src/hcs-27/merkle.ts"],"sourcesContent":["import { createHash } from 'crypto';\nimport {\n  hcs27ConsistencyProofSchema,\n  hcs27InclusionProofSchema,\n  type HCS27ConsistencyProof,\n  type HCS27InclusionProof,\n} from './types';\n\nfunction normalizeJsonValue(value: unknown): unknown {\n  if (\n    value === null ||\n    typeof value === 'boolean' ||\n    typeof value === 'number' ||\n    typeof value === 'string'\n  ) {\n    if (typeof value === 'number' && !Number.isFinite(value)) {\n      throw new Error('JSON numbers must be finite');\n    }\n    return value;\n  }\n\n  if (Array.isArray(value)) {\n    return Array.from(value, item =>\n      item === undefined ? null : normalizeJsonValue(item),\n    );\n  }\n\n  if (typeof value === 'object') {\n    const toJSON = (value as { toJSON?: () => unknown }).toJSON;\n    if (typeof toJSON === 'function') {\n      return normalizeJsonValue(toJSON.call(value));\n    }\n\n    const result: Record<string, unknown> = {};\n    for (const [key, item] of Object.entries(value)) {\n      if (item !== undefined) {\n        result[key] = normalizeJsonValue(item);\n      }\n    }\n    return result;\n  }\n\n  throw new Error(`Unsupported JSON value type: ${typeof value}`);\n}\n\nfunction formatNumber(value: number): string {\n  if (Object.is(value, -0)) {\n    return '0';\n  }\n  return value.toString();\n}\n\nfunction decodeBase64(value: string, fieldName: string): Buffer {\n  try {\n    if (!value) {\n      throw new Error('empty base64');\n    }\n    const decoded = Buffer.from(value, 'base64');\n    if (decoded.toString('base64') !== value) {\n      throw new Error('non-canonical base64');\n    }\n    return decoded;\n  } catch {\n    throw new Error(`${fieldName} must be valid base64`);\n  }\n}\n\nfunction writeCanonicalJson(value: unknown): string {\n  if (value === null) {\n    return 'null';\n  }\n  if (typeof value === 'boolean') {\n    return value ? 'true' : 'false';\n  }\n  if (typeof value === 'string') {\n    return JSON.stringify(value);\n  }\n  if (typeof value === 'number') {\n    return formatNumber(value);\n  }\n  if (Array.isArray(value)) {\n    return `[${value.map(item => writeCanonicalJson(item)).join(',')}]`;\n  }\n  if (typeof value === 'object') {\n    const entries = Object.entries(value).sort(([left], [right]) =>\n      left < right ? -1 : left > right ? 1 : 0,\n    );\n    return `{${entries\n      .map(\n        ([key, item]) => `${JSON.stringify(key)}:${writeCanonicalJson(item)}`,\n      )\n      .join(',')}}`;\n  }\n  throw new Error(`Unsupported JSON value type: ${typeof value}`);\n}\n\nfunction parseTreeSize(value: number | string): bigint {\n  return typeof value === 'number' ? BigInt(value) : BigInt(value);\n}\n\nfunction leastSignificantBit(value: bigint): bigint {\n  return value & 1n;\n}\n\nfunction isExactPowerOfTwo(value: bigint): boolean {\n  return value !== 0n && (value & (value - 1n)) === 0n;\n}\n\nfunction largestPowerOfTwoLessThan(value: number): number {\n  if (value <= 1) {\n    return 0;\n  }\n\n  let result = 1;\n  while (result << 1 < value) {\n    result <<= 1;\n  }\n  return result;\n}\n\nexport function canonicalizeHCS27Json(value: unknown): Buffer {\n  const normalized = normalizeJsonValue(value);\n  return Buffer.from(writeCanonicalJson(normalized), 'utf8');\n}\n\nexport function emptyHCS27Root(): Buffer {\n  return createHash('sha256').update(Buffer.alloc(0)).digest();\n}\n\nexport function hashHCS27Leaf(canonicalEntry: Buffer | Uint8Array): Buffer {\n  return createHash('sha256')\n    .update(Buffer.from([0x00]))\n    .update(Buffer.from(canonicalEntry))\n    .digest();\n}\n\nexport function hashHCS27Node(\n  left: Buffer | Uint8Array,\n  right: Buffer | Uint8Array,\n): Buffer {\n  return createHash('sha256')\n    .update(Buffer.from([0x01]))\n    .update(Buffer.from(left))\n    .update(Buffer.from(right))\n    .digest();\n}\n\nexport function merkleRootFromCanonicalEntries(\n  entries: ReadonlyArray<Buffer | Uint8Array>,\n): Buffer {\n  if (entries.length === 0) {\n    return emptyHCS27Root();\n  }\n  if (entries.length === 1) {\n    return hashHCS27Leaf(entries[0]);\n  }\n\n  const split = largestPowerOfTwoLessThan(entries.length);\n  const left = merkleRootFromCanonicalEntries(entries.slice(0, split));\n  const right = merkleRootFromCanonicalEntries(entries.slice(split));\n  return hashHCS27Node(left, right);\n}\n\nexport function merkleRootFromEntries(entries: ReadonlyArray<unknown>): Buffer {\n  const canonicalEntries = entries.map(entry => canonicalizeHCS27Json(entry));\n  return merkleRootFromCanonicalEntries(canonicalEntries);\n}\n\nexport function leafHashHexFromEntry(entry: unknown): string {\n  return hashHCS27Leaf(canonicalizeHCS27Json(entry)).toString('hex');\n}\n\nexport function verifyInclusionProof(\n  params:\n    | HCS27InclusionProof\n    | {\n        leafIndex: number;\n        treeSize: number;\n        leafHashHex: string;\n        path: string[];\n        expectedRootB64: string;\n      },\n): boolean {\n  let leafIndex: bigint;\n  let treeSize: bigint;\n  let leafHashHex: string;\n  let path: string[];\n  let expectedRootB64: string;\n\n  if ('leafHash' in params) {\n    const proof = hcs27InclusionProofSchema.parse(params);\n    leafIndex = BigInt(proof.leafIndex);\n    treeSize = BigInt(proof.treeSize);\n    leafHashHex = proof.leafHash;\n    path = proof.path;\n    expectedRootB64 = proof.rootHash;\n  } else {\n    leafIndex = parseTreeSize(params.leafIndex);\n    treeSize = parseTreeSize(params.treeSize);\n    leafHashHex = params.leafHashHex;\n    path = params.path;\n    expectedRootB64 = params.expectedRootB64;\n  }\n\n  if (treeSize <= 0n) {\n    throw new Error('treeSize must be greater than zero for inclusion proofs');\n  }\n  if (leafIndex < 0n || leafIndex >= treeSize) {\n    throw new Error('leafIndex must be less than treeSize');\n  }\n  if (!/^(?:[0-9a-f]{2})+$/i.test(leafHashHex.trim())) {\n    throw new Error('leafHash must be valid hex');\n  }\n\n  let current: Buffer;\n  try {\n    current = Buffer.from(leafHashHex.trim(), 'hex');\n  } catch {\n    throw new Error('leafHash must be valid hex');\n  }\n\n  let fn = leafIndex;\n  let sn = treeSize - 1n;\n\n  for (const [index, node] of path.entries()) {\n    if (sn === 0n) {\n      return false;\n    }\n\n    const sibling = decodeBase64(node, `path[${index}]`);\n\n    if (leastSignificantBit(fn) === 1n || fn === sn) {\n      current = hashHCS27Node(sibling, current);\n      if (leastSignificantBit(fn) === 0n) {\n        while (leastSignificantBit(fn) === 0n && fn !== 0n) {\n          fn /= 2n;\n          sn /= 2n;\n        }\n      }\n    } else {\n      current = hashHCS27Node(current, sibling);\n    }\n\n    fn /= 2n;\n    sn /= 2n;\n  }\n\n  return sn === 0n && current.toString('base64') === expectedRootB64;\n}\n\nexport function verifyConsistencyProof(\n  params:\n    | HCS27ConsistencyProof\n    | {\n        oldTreeSize: number;\n        newTreeSize: number;\n        oldRootB64: string;\n        newRootB64: string;\n        consistencyPath: string[];\n      },\n): boolean {\n  let oldTreeSize: bigint;\n  let newTreeSize: bigint;\n  let oldRootB64: string;\n  let newRootB64: string;\n  let consistencyPath: string[];\n\n  if ('oldRootHash' in params) {\n    const proof = hcs27ConsistencyProofSchema.parse(params);\n    oldTreeSize = BigInt(proof.oldTreeSize);\n    newTreeSize = BigInt(proof.newTreeSize);\n    oldRootB64 = proof.oldRootHash;\n    newRootB64 = proof.newRootHash;\n    consistencyPath = proof.consistencyPath;\n  } else {\n    oldTreeSize = parseTreeSize(params.oldTreeSize);\n    newTreeSize = parseTreeSize(params.newTreeSize);\n    oldRootB64 = params.oldRootB64;\n    newRootB64 = params.newRootB64;\n    consistencyPath = params.consistencyPath;\n  }\n\n  if (oldTreeSize < 0n || newTreeSize < 0n) {\n    throw new Error('tree sizes must be non-negative');\n  }\n  if (oldTreeSize === 0n) {\n    return true;\n  }\n  if (oldTreeSize === newTreeSize) {\n    decodeBase64(oldRootB64, 'oldRootHash');\n    decodeBase64(newRootB64, 'newRootHash');\n    return oldRootB64 === newRootB64 && consistencyPath.length === 0;\n  }\n  if (oldTreeSize > newTreeSize || consistencyPath.length === 0) {\n    return false;\n  }\n\n  const path = consistencyPath.map((node, index) =>\n    decodeBase64(node, `consistencyPath[${index}]`),\n  );\n  if (isExactPowerOfTwo(oldTreeSize)) {\n    path.unshift(decodeBase64(oldRootB64, 'oldRootHash'));\n  }\n\n  let fn = oldTreeSize - 1n;\n  let sn = newTreeSize - 1n;\n\n  while (leastSignificantBit(fn) === 1n) {\n    fn /= 2n;\n    sn /= 2n;\n  }\n\n  const firstHash = Buffer.from(path[0]);\n  let fr: Uint8Array = Buffer.from(firstHash);\n  let sr: Uint8Array = Buffer.from(firstHash);\n\n  for (const nodeHash of path.slice(1)) {\n    if (sn === 0n) {\n      return false;\n    }\n\n    if (leastSignificantBit(fn) === 1n || fn === sn) {\n      fr = hashHCS27Node(nodeHash, fr);\n      sr = hashHCS27Node(nodeHash, sr);\n      if (leastSignificantBit(fn) === 0n) {\n        while (leastSignificantBit(fn) === 0n && fn !== 0n) {\n          fn /= 2n;\n          sn /= 2n;\n        }\n      }\n    } else {\n      sr = hashHCS27Node(sr, nodeHash);\n    }\n\n    fn /= 2n;\n    sn /= 2n;\n  }\n\n  return (\n    sn === 0n &&\n    Buffer.from(fr).toString('base64') === oldRootB64 &&\n    Buffer.from(sr).toString('base64') === newRootB64\n  );\n}\n"],"names":[],"mappings":"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"}