@ensdomains/merkle-builder 0.0.1

package/dist/index.js

@@ -0,0 +1,882 @@
+// src/utils.ts
+import { keccak, bytes_from_hex, hex_from_bytes } from "@adraffy/keccak";
+function keccak256(v) {
+  return keccak().update(v).bytes;
+}
+function concat(...args) {
+  const n = args.reduce((a, x) => a + x.length, 0);
+  const v = new Uint8Array(n);
+  let pos = 0;
+  for (const x of args) {
+    v.set(x, pos);
+    pos += x.length;
+  }
+  return v;
+}
+function followSlot(slot, key) {
+  return keccak256(concat(key, toBytes(slot, 32)));
+}
+function trimLeadingZeros(v) {
+  let i = 0;
+  while (v[i] === 0) ++i;
+  return v.slice(i);
+}
+function toBytes(x, size) {
+  if (typeof x === "string") {
+    if (x.startsWith("0x")) x = x.slice(2);
+  } else {
+    x = x ? x.toString(16) : "";
+  }
+  size ??= x.length + 1 >> 1;
+  size <<= 1;
+  return bytes_from_hex(x.padStart(size, "0").slice(-size));
+}
+function toBigInt(v) {
+  return v.length ? BigInt(toHex(v)) : 0n;
+}
+function toHex(v) {
+  return `0x${hex_from_bytes(v)}`;
+}
+
+// src/trie.ts
+var EMPTY_BYTES = new Uint8Array(0);
+var EMPTY_LEAF = Object.freeze({
+  path: EMPTY_BYTES,
+  data: EMPTY_BYTES
+});
+var RLP_NULL = encodeRlpBytes(EMPTY_BYTES);
+var RLP_EMPTY = encodeRlpList([encodeRlpList([])]);
+var HASH_NULL = keccak256(RLP_NULL);
+function isBranch(node) {
+  return !!node && "children" in node;
+}
+function isExtension(node) {
+  return !!node && "child" in node;
+}
+function isLeaf(node) {
+  return !!node && "data" in node;
+}
+function isEmptyLeaf(node) {
+  return isLeaf(node) && !node.path.length && !node.data.length;
+}
+function common(a, b) {
+  let i = 0;
+  while (i < a.length && i < b.length && a[i] === b[i]) ++i;
+  return i;
+}
+function startsWith(path, prefix) {
+  const n = prefix.length;
+  if (path.length < n) return 0;
+  for (let i = 0; i < n; ++i) if (path[i] !== prefix[i]) return 0;
+  return n;
+}
+function copyNode(node, copyPath = true) {
+  if (isLeaf(node)) {
+    return newLeaf(
+      copyPath && node.path.length ? node.path.slice() : node.path,
+      node.data
+    );
+  } else if (isExtension(node)) {
+    const copy = { ...node };
+    if (copyPath && copy.path.length) copy.path = copy.path.slice();
+    copy.child = copyNode(copy.child, copyPath);
+    return copy;
+  } else if (isBranch(node)) {
+    const copy = { ...node };
+    copy.children = copy.children.map((x) => copyNode(x, copyPath));
+    return copy;
+  } else {
+    return node;
+  }
+}
+function findLeaf(node, path) {
+  while (node) {
+    if (isBranch(node)) {
+      if (!path.length) return;
+      node = node.children[path[0]];
+      path = path.subarray(1);
+    } else if (isExtension(node)) {
+      const i = startsWith(path, node.path);
+      if (!i) return;
+      node = node.child;
+      path = path.subarray(i);
+    } else if (startsWith(path, node.path)) {
+      return node;
+    } else {
+      return;
+    }
+  }
+}
+function getProof(node, path) {
+  const ret = [];
+  do {
+    ret.push(encodeNode(node));
+    if (isBranch(node)) {
+      if (!path.length) break;
+      node = node.children[path[0]];
+      path = path.subarray(1);
+    } else if (isExtension(node)) {
+      const i = startsWith(path, node.path);
+      if (!i) break;
+      node = node.child;
+      path = path.subarray(i);
+    } else {
+      break;
+    }
+  } while (node);
+  return ret;
+}
+function insertLeaf(node, path, data) {
+  if (!node) {
+    return newLeaf(path, data);
+  } else if (isBranch(node)) {
+    const i = path[0];
+    const children = node.children.slice();
+    children[i] = insertLeaf(children[i], path.subarray(1), data);
+    return { children };
+  } else if (isExtension(node)) {
+    const other = node.path;
+    const i = common(other, path);
+    if (i === other.length) {
+      return {
+        path: other,
+        child: insertLeaf(node.child, path.subarray(i), data)
+      };
+    }
+    const b = newBranch();
+    const rest = other.subarray(i + 1);
+    b.children[other[i]] = rest.length ? { path: rest, child: node.child } : node.child;
+    b.children[path[i]] = newLeaf(path.subarray(i + 1), data);
+    return i ? { path: path.subarray(0, i), child: b } : b;
+  } else {
+    const other = node.path;
+    const i = common(other, path);
+    if (i === other.length && i === path.length) {
+      return newLeaf(path, data);
+    }
+    const b = newBranch();
+    if (i < other.length) {
+      b.children[other[i]] = newLeaf(other.subarray(i + 1), node.data);
+    }
+    b.children[path[i]] = newLeaf(path.subarray(i + 1), data);
+    return i ? { path: path.subarray(0, i), child: b } : b;
+  }
+}
+function extractNode(node, path) {
+  while (node) {
+    if (!path.length) return node;
+    if (isBranch(node)) {
+      node = node.children[path[0]];
+      path = path.subarray(1);
+    } else if (isExtension(node)) {
+      const part = node.path;
+      const i = common(path, part);
+      if (i === part.length) {
+        node = node.child;
+        path = path.subarray(i);
+      } else if (i === path.length) {
+        return { path: part.subarray(i), child: node.child };
+      } else {
+        return;
+      }
+    } else {
+      const part = node.path;
+      const i = common(path, part);
+      if (i === path.length) {
+        return { path: part.subarray(i), data: node.data };
+      } else {
+        return;
+      }
+    }
+  }
+}
+function deleteNode(node, path) {
+  if (!node || !path.length) return;
+  if (isBranch(node)) {
+    const i = path[0];
+    if (!node.children[i]) return node;
+    const children = node.children.slice();
+    let child = children[i] = deleteNode(children[i], path.subarray(1));
+    if (child) return { children };
+    let index = -1;
+    for (let j = 0; j < children.length; ++j) {
+      if (children[j]) {
+        if (index >= 0) return { children };
+        index = j;
+      }
+    }
+    child = children[index];
+    if (isBranch(child)) return { path: Uint8Array.of(index), child };
+    path = Uint8Array.of(index, ...child.path);
+    return isExtension(child) ? { path, child: child.child } : newLeaf(path, child.data);
+  } else if (isExtension(node)) {
+    const i = common(node.path, path);
+    if (!i) return node;
+    if (i === path.length) return;
+    const child = deleteNode(node.child, path.subarray(i));
+    if (!child) return;
+    if (isBranch(child)) return { path: node.path, child };
+    path = concat(node.path, child.path);
+    return isExtension(child) ? { path, child: child.child } : newLeaf(path, child.data);
+  } else {
+    if (common(node.path, path) === path.length) return;
+    return node;
+  }
+}
+function newLeaf(path, data) {
+  if (!data.length) {
+    data = EMPTY_BYTES;
+    if (!path.length) return EMPTY_LEAF;
+  } else if (!data[0]) {
+    throw new Error(`not trim: ${toHex(data)}`);
+  }
+  return { path, data };
+}
+function newBranch() {
+  return { children: Array(16).fill(void 0) };
+}
+function encodeNode(node) {
+  if (!node) {
+    return RLP_NULL;
+  } else if (isBranch(node)) {
+    return node.cache ??= encodeRlpList([
+      ...node.children.map(encodeNodeRef),
+      RLP_NULL
+    ]);
+  } else if (isExtension(node)) {
+    return encodeRlpList([
+      encodeRlpBytes(encodePath(node.path, false)),
+      encodeNodeRef(node.child)
+    ]);
+  } else {
+    return encodeRlpList([
+      encodeRlpBytes(encodePath(node.path, true)),
+      encodeRlpBytes(encodeRlpBytes(node.data))
+    ]);
+  }
+}
+function encodeNodeRef(node) {
+  if (!node) {
+    return RLP_NULL;
+  } else if (isEmptyLeaf(node)) {
+    return RLP_EMPTY;
+  } else {
+    const v = encodeNode(node);
+    return encodeRlpBytes(v.length < 32 ? v : keccak256(v));
+  }
+}
+function clearCache(node) {
+  if (isBranch(node)) {
+    node.cache = void 0;
+    node.children.forEach(clearCache);
+  } else if (isExtension(node)) {
+    clearCache(node.child);
+  }
+}
+function getRootHash(node) {
+  if (!node) return HASH_NULL;
+  const v = encodeNode(node);
+  return v.length < 32 ? v : keccak256(v);
+}
+function toNibblePath(v) {
+  if (!v.length) return EMPTY_BYTES;
+  const u = new Uint8Array(v.length << 1);
+  let i = 0;
+  for (const x of v) {
+    u[i++] = x >> 4;
+    u[i++] = x & 15;
+  }
+  return u;
+}
+function encodePath(path, leaf) {
+  const v = new Uint8Array(1 + (path.length >> 1));
+  if (leaf) v[0] = 32;
+  const odd = path.length & 1;
+  if (path.length & 1) v[0] |= 16 | path[0];
+  for (let i = odd, j = 1; i < path.length; i += 2, ++j) {
+    v[j] = path[i] << 4 | path[i + 1];
+  }
+  return v;
+}
+function encodeRlpLength(start, length) {
+  const max = 55;
+  if (length <= max) return Uint8Array.of(start + length);
+  const v = new Uint8Array(8);
+  let i = v.length;
+  for (; length; length >>= 8, ++start) {
+    v[--i] = length;
+  }
+  v[--i] = start + max;
+  return v.subarray(i);
+}
+function encodeRlpList(m) {
+  return concat(
+    encodeRlpLength(
+      192,
+      m.reduce((a, x) => a + x.length, 0)
+    ),
+    ...m
+  );
+}
+function encodeRlpBytes(v) {
+  const max = 128;
+  if (v.length === 1 && v[0] < max) return v;
+  return concat(encodeRlpLength(max, v.length), v);
+}
+
+// src/coder.ts
+var TY_NULL = 0;
+var TY_BRANCH = 1;
+var TY_EXTENSION = 2;
+var TY_EMPTY_LEAF = 3;
+var TY_LEAF = 4;
+var TY_BRANCH_WITH_CACHE = 5;
+var MAX_SIZE = (1 << 22) - 1;
+var Coder = class {
+  constructor(buf = new Uint8Array(1024)) {
+    this.buf = buf;
+  }
+  static getByteCount(node) {
+    const c = new this();
+    c.writeNode(node);
+    return c.pos;
+  }
+  pos = 0;
+  reset() {
+    this.pos = 0;
+  }
+  expand(need) {
+    const required = this.pos + need;
+    let size = this.buf.length;
+    if (required <= size) return;
+    while (size < required) size <<= 1;
+    const v = new Uint8Array(size);
+    v.set(this.buf);
+    this.buf = v;
+  }
+  require(need) {
+    if (need && this.pos + need > this.buf.length) {
+      throw new Error(`eof: ${this.pos + need} > ${this.buf.length}`);
+    }
+  }
+  readByte() {
+    this.require(1);
+    return this.buf[this.pos++];
+  }
+  writeByte(x) {
+    this.expand(1);
+    this.buf[this.pos++] = x;
+  }
+  readSize() {
+    let size = this.readByte();
+    if (size & 128) {
+      const next = this.readByte();
+      size = (size & 127) + ((next & 127) << 7);
+      if (next & 128) {
+        size += this.readByte() << 14;
+      }
+    }
+    return size;
+  }
+  writeSize(size) {
+    if (size < 128) {
+      this.writeByte(size);
+    } else {
+      this.writeByte(size | 128);
+      size >>= 7;
+      if (size < 128) {
+        this.writeByte(size);
+      } else {
+        this.writeByte(size | 128);
+        size >>= 7;
+        if (size >> 8) throw new RangeError("overflow");
+        this.writeByte(size);
+      }
+    }
+  }
+  readBytes(n) {
+    if (!n) return EMPTY_BYTES;
+    this.require(n);
+    return this.buf.slice(this.pos, this.pos += n);
+  }
+  writeBytes(v) {
+    this.expand(v.length);
+    this.buf.set(v, this.pos);
+    this.pos += v.length;
+  }
+  readSizedBytes() {
+    return this.readBytes(this.readSize());
+  }
+  writeSizedBytes(v) {
+    this.writeSize(v.length);
+    this.writeBytes(v);
+  }
+  readPath() {
+    const n = this.readByte();
+    return toNibblePath(this.readBytes(n + 1 >> 1)).subarray(0, n);
+  }
+  writePath(v) {
+    const n = v.length + 1 >> 1;
+    this.expand(1 + n);
+    this.buf[this.pos++] = v.length;
+    for (let i = 0; i < v.length; i += 2) {
+      this.buf[this.pos++] = v[i] << 4 | (v[i + 1] ?? 0);
+    }
+  }
+  readNodes(length = 16) {
+    return Array.from({ length }, () => this.readNode());
+  }
+  readNode() {
+    const ty = this.readByte();
+    switch (ty) {
+      case TY_NULL:
+        return;
+      case TY_BRANCH_WITH_CACHE:
+        return {
+          children: this.readNodes(),
+          cache: this.readSizedBytes()
+        };
+      case TY_BRANCH:
+        return { children: this.readNodes() };
+      case TY_EXTENSION: {
+        const path = this.readPath();
+        const child = this.readNode();
+        if (!isBranch(child)) throw new Error("bug");
+        return { path, child };
+      }
+      case TY_EMPTY_LEAF:
+        return EMPTY_LEAF;
+      case TY_LEAF:
+        return {
+          path: this.readPath(),
+          data: this.readSizedBytes()
+        };
+      default:
+        throw new Error(`unknown type: ${ty}`);
+    }
+  }
+  writeNode(node, includeCache) {
+    if (!node) {
+      this.writeByte(TY_NULL);
+    } else if (isBranch(node)) {
+      const cache = includeCache === void 0 ? node.cache : includeCache ? encodeNode(node) : void 0;
+      this.writeByte(cache ? TY_BRANCH_WITH_CACHE : TY_BRANCH);
+      for (const x of node.children) {
+        this.writeNode(x, includeCache);
+      }
+      if (cache) this.writeSizedBytes(cache);
+    } else if (isExtension(node)) {
+      this.writeByte(TY_EXTENSION);
+      this.writePath(node.path);
+      this.writeNode(node.child, includeCache);
+    } else if (isEmptyLeaf(node)) {
+      this.writeByte(TY_EMPTY_LEAF);
+    } else {
+      this.writeByte(TY_LEAF);
+      this.writePath(node.path);
+      this.writeSizedBytes(node.data);
+    }
+  }
+  get bytes() {
+    return this.buf.subarray(0, this.pos);
+  }
+};
+
+// src/inspect.ts
+function getByteCount(node, sizeOf = (v) => v.length) {
+  if (!node) {
+    return 0;
+  } else if (isLeaf(node)) {
+    return sizeOf(node.path) + sizeOf(node.data);
+  } else if (isExtension(node)) {
+    return sizeOf(node.path) + getByteCount(node.child, sizeOf);
+  } else {
+    return node.children.reduce(
+      (a, x) => a + getByteCount(x, sizeOf),
+      (node.cache ? sizeOf(node.cache) : 0) + node.children.length
+    );
+  }
+}
+function getLeafCount(node) {
+  if (!node) {
+    return 0;
+  } else if (isLeaf(node)) {
+    return 1;
+  } else if (isExtension(node)) {
+    return getLeafCount(node.child);
+  } else {
+    return node.children.reduce((a, x) => a + getLeafCount(x), 0);
+  }
+}
+function getNodeCount(node) {
+  if (!node) {
+    return 0;
+  } else if (isLeaf(node)) {
+    return 1;
+  } else if (isExtension(node)) {
+    return 1 + getNodeCount(node.child);
+  } else {
+    return node.children.reduce((a, x) => a + getNodeCount(x), 1);
+  }
+}
+function getNodeType(node) {
+  if (isBranch(node)) {
+    return "branch";
+  } else if (isExtension(node)) {
+    return "extension";
+  } else if (isLeaf(node)) {
+    return "leaf";
+  } else {
+    return "null";
+  }
+}
+
+// src/json.ts
+import { hex_from_bytes as hex_from_bytes2 } from "@adraffy/keccak";
+var MORE = {
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return "\x1B[37m...\x1B[0m";
+  }
+};
+function toJSON(node, depth = Infinity) {
+  if (!node) return null;
+  if (depth < 0) return MORE;
+  if (isBranch(node)) {
+    return Object.fromEntries(
+      node.children.flatMap(
+        (x, i) => x ? [[toNibbleChar(i), x && toJSON(x, depth - 1)]] : []
+      )
+    );
+  } else if (isExtension(node)) {
+    return [nibbleStr(node.path), toJSON(node.child, depth - 1)];
+  } else if (node.path.length) {
+    return [nibbleStr(node.path), hex_from_bytes2(node.data)];
+  } else {
+    return hex_from_bytes2(node.data);
+  }
+}
+function fromJSON(json) {
+  switch (typeof json) {
+    case "string":
+      return newLeaf(EMPTY_BYTES, toBytes(json));
+    case "object": {
+      if (json === null) return;
+      if (Array.isArray(json) && json.length === 2) {
+        const path = Uint8Array.from(json[0], fromNibbleChar);
+        const child = fromJSON(json[1]);
+        if (isBranch(child)) {
+          return { path, child };
+        } else if (isExtension(child)) {
+          return { path: concat(path, child.path), child: child.child };
+        } else if (child) {
+          return newLeaf(concat(path, child.path), child.data);
+        }
+      } else if (json.constructor === Object) {
+        const b = newBranch();
+        for (const [k, x] of Object.entries(json)) {
+          b.children[fromNibbleChar(k)] = fromJSON(x);
+        }
+        return b;
+      }
+    }
+  }
+  throw new TypeError("invalid json");
+}
+function nibbleStr(path) {
+  return Array.from(path, toNibbleChar).join("");
+}
+function toNibbleChar(nibble) {
+  return String.fromCharCode((nibble < 10 ? 48 : 55) + nibble);
+}
+function fromNibbleChar(ch) {
+  if (ch.length === 1) {
+    const cp = ch.charCodeAt(0);
+    if (cp >= 48 && cp <= 57) {
+      return cp - 48;
+    } else if (cp >= 65 && cp <= 70) {
+      return cp - 55;
+    }
+  }
+  throw new TypeError(`invalid nibble: "${ch}"`);
+}
+
+// src/kv.ts
+function insertBytes(node, slot, value, mode = "delete") {
+  if (slot.length !== 32) throw new Error(`expected bytes32 slot`);
+  const key = keccak256(slot);
+  const path = toNibblePath(key);
+  let oldSize = 0;
+  if (mode !== "ignore") {
+    const prior = findLeaf(node, path)?.data;
+    if (prior?.length && prior[prior.length - 1] & 1) {
+      oldSize = Number(toBigInt(prior) >> 1n);
+    }
+  }
+  let pos = 0;
+  if (value.length < 32) {
+    if (!value.length && mode === "delete") {
+      node = deleteNode(node, path);
+    } else {
+      const word = bytes32(value);
+      word[31] = value.length << 1;
+      node = insertLeaf(node, path, trimLeadingZeros(word));
+    }
+  } else {
+    node = insertLeaf(node, path, toBytes(BigInt(value.length) << 1n | 1n));
+    for (; pos < value.length; increment(key)) {
+      const end = pos + 32;
+      node = insertLeaf(
+        node,
+        toNibblePath(keccak256(key)),
+        trimLeadingZeros(
+          end > value.length ? bytes32(value.subarray(pos)) : value.subarray(pos, end)
+        )
+      );
+      pos = end;
+    }
+  }
+  if (mode === "delete") {
+    for (; pos < oldSize; increment(key), pos += 32) {
+      node = deleteNode(node, toNibblePath(keccak256(key)));
+    }
+  } else if (mode === "zero") {
+    for (; pos < oldSize; increment(key), pos += 32) {
+      node = insertLeaf(node, toNibblePath(keccak256(key)), EMPTY_BYTES);
+    }
+  }
+  return node;
+}
+function increment(v, max = 255) {
+  let i = v.length;
+  while (i && v[i - 1] === max) --i;
+  if (i) {
+    ++v[i - 1];
+    v.fill(0, i);
+  } else {
+    v.fill(0);
+  }
+}
+function bytes32(v) {
+  const word = new Uint8Array(32);
+  word.set(v);
+  return word;
+}
+
+// src/mimc.ts
+var FIELD = 0x12ab655e9a2ca55660b44d1e5c37b00159aa76fed00000010a11800000000001n;
+var ROUND_CONSTANTS = [
+  0x0efda9332fcec268a3bbd0567797ce650be481c79da27f58b1a51ada4a91b014n,
+  0x05253862ca9b15c2bd33e1a2b830659b7ae3657aacfa8986eec35d8ec2dd3446n,
+  0x0db5be05400d438b9facd4a269a49031e8c7f947887a7c8653aae1675075f08dn,
+  0x07850deb84c4b38c891c03f7acc0f0e0602877a2ae969dcd0b10d7facf26dddbn,
+  0x01c2e148c40ea201b748bee72845b349bfa4a4497837af0d569ae47afc6e4243n,
+  0x005a472abfb0d5d4b09a0da6d9d4c7ab93bf68299dc5222dc6ef81407825dba9n,
+  0x03b0d15d7b62c8b4cfbce18816baeabb2e3df2d9a731d9d248d2f0498bdec1e4n,
+  0x04e8da009db8982a082983402626f1f68655a4a3c83be89c165ba656be14d726n,
+  0x02dcc7fbe0034e4fd51853c69fa7161a043c6757df0b3022fd8628c221b04c01n,
+  0x0ef15ea4cf191c23a6eba0d9f4c6c978a7bb172b196d13438c30c1ce50aeefecn,
+  0x0ddda0ea4d7aeda047f66513386eab0c970ea0f302b6227a1a7e64aef63840e9n,
+  0x11c526b58d39911c310b2a808cf84fd690f713c06d4016ff30c05aded412af7an,
+  0x056b338761a8093e7575ab89a9f375f59c61049079a2e5d1120dbf4adf7a9bb5n,
+  0x05fc79e450ea6c00b641fdf50f5ee15c0ec5baf629ccb26d553553adf1792b00n,
+  0x1168acb1e68011e4b6ff861a9f84e4ac38d250941c8536f214a0ce4f68bdb5a3n,
+  0x06d4d245e2259b3166774189238cfc1b4ae5defd98f62899f0d846d20a005b91n,
+  0x123313cced613293c40586b110f8e4244cd67cc4380c8f5df4ec60f42216ce28n,
+  0x0acf9981fe2d6f97d7fa27873a0a368c2b19b10d15f2460a59512c4381ca0379n,
+  0x011e73f99cc798e236f1fb1f38144984fed0a2cdd836d7860099423cce8c491en,
+  0x0a8d98d4f22ed367167e54617b0701e64f0f9a4b17e0808eeac420473c18bcben,
+  0x0e9d4c3fe8fed7780e4b179314207924caebf54185c786400384a8679b6c7252n,
+  0x11d37287b2e163e78261cdcc9e4d723b0a81099340c5cfa245eccfb9ee920142n,
+  0x05b231b706fb2967b2b90bade17c758c62201b5a4e04f020cdf2af76c12422f0n,
+  0x0dcfd40018b5bf7bb3397d4ce2a24130ae7d74c41e48f2a25a48132f897a5ac2n,
+  0x0534aaf5c42188955008e47ba93e156c7d32406566cb85f6183bf6144d8a3ee2n,
+  0x023cd78594054aa62b3292f3429491566819cb081159afef6c0d12a945aa0590n,
+  0x007ca89d69ee508f26d2500ece5b01925c9728aef78493806f58a2b807c6da4dn,
+  0x05192bd62077895fa33a95382ba2ea0dd65ed66281c6b7a09acc94003238df37n,
+  0x0d0ead8a1699babd8e6b7e3f3811463e8cfafae1915967ad4342ca59465c4014n,
+  0x11c0cabe4b1e2444d8915e6a411908faf20cf1feeb59918abde560595ebb5f4fn,
+  0x0f0c1c73b3c6463138527609f33d4981b21444c39d1f00c172f51c3c9aa43574n,
+  0x0861d628f74762a601963dd1823ed11b9dd2456940b41659ac02fe1232355a64n,
+  0x110df129163a9336afa7b9757f15f300aeb954e92b3af524222b84096d1274fdn,
+  0x04c609941ec5da50d43b8d6d7d45fdd4faa8bb69929fc3337ddfc1bee29f7b94n,
+  0x07a63ade8da839446b58f5d1b7fdc9432dbe55467a2b87c1779e4ce62a59e432n,
+  0x120dbf222fc5d5337f22cfe76ea5597030bc328f5ef7b927678f123be9c2a394n,
+  0x0b33e4820a40248cdbc3c27d7dfab70fd4b31ee9f62b2e1e048e23f9b12d5b71n,
+  0x10b998b32a4e17a795d120a590e238dead3a2761cfcc9cce00b0b5c9a8656086n,
+  0x0a98ebc6e3643fb6112262f125da98c0dc9eeb5c5e652716f368cf96b8888ed3n,
+  0x0006ce51116858059370af176e5d32b99b8fd443d520fe34588c6254df7514f5n,
+  0x0b2dddc8994767c7d3632cc7bc089becf8ef3b65540fb4709b8cc78ba12b044bn,
+  0x08837cf3399fbfff03fc2e6cbb1a3b205a5a28757c827730ccd0c2f0c90fff3bn,
+  0x0c238d5f2c384a72477fbdce23d461ad73d4a20f8acb2de069ec6b034b7d8c54n,
+  0x0f0e46c03bd29b0cad6857149959c77f9e4f96c6688d3c2c64e228bcc0893ba4n,
+  0x0d7dbd25add9892e2ea8951086a653298f4e4261e6bcdb3d980b9a45c9f4f3a9n,
+  0x1197bc33ae17572ff6c8671d7a3a52f761305ba4f3a93c582e95c9f6d21dd600n,
+  0x10c0f787b87b60b08241ca6547299f3afe7d86374858661f3db021676d573566n,
+  0x0d527557a2a71d92e0b0c5230b02b5db478d6abd87d24caee5e9f325efec0298n,
+  0x046e586141d405df5efb10855b7ea8009fdac1732b676f90de97a3e65fab3f42n,
+  0x02e91572a13a6baf97560b43b5b862aebd8b7d95c0fda9c097d823cc9ef0599en,
+  0x0a12c428ae449ef925394565ac50d0adb37e9e48873cf7df892b08a7b5c02875n,
+  0x053d51710289df29fdcd07b74954d10edb2a29ce26f58b0868bfa608b976d162n,
+  0x107983a1ea61c3c634124a87ab1271bc68dbbf1f455033dba37f441e942da248n,
+  0x02f05b8c3d5883d63ad8e0fb9d5dfd79fed0a7476208a11ca79905cf50a8627an,
+  0x0728f029842765bb9a7b662cc646a328bea710b0def51f6c6a0d8e3ee9286a2fn,
+  0x07aee6d598f4aed60276e302085feae4608f4b249347f581ea9e246aa7b2bd2dn,
+  0x0973293a99aab1398c81147a84d50bfa6aa95c659b7a4a2c153f21a13294caa6n,
+  0x0f56f597f2a94ff70aed4abd9b14a863808ecffcd706f566a9065b6bf515cba5n,
+  0x08d6e679d99527436d1b27315b5933cf75aaad990d3a2969032bc5595f72ed37n,
+  0x0ecf9edc13aa60341dde23bdadf7a719337256129297b85719cd06d173e54320n,
+  0x0f647c810044463684d83b28b6a17aef6a71db48f9af54c58c9919ded4974d2en,
+  0x0f63f31b9849bcdbf503fd3b51ab77ca37a73a892a2eb5f9328fd4f2e234d20an
+];
+function pow2(x) {
+  return x * x % FIELD;
+}
+function mimcHash(v) {
+  let h = 0n;
+  for (const x of v) {
+    let y = x;
+    for (const c of ROUND_CONSTANTS) {
+      const temp = (y + h + c) % FIELD;
+      y = pow2(pow2(pow2(pow2(temp)))) * temp;
+    }
+    h += x + y + h;
+  }
+  return h % FIELD;
+}
+
+// src/surgery.ts
+function pluckLimbs(node, depth) {
+  if (!node || depth <= 0) return { trunk: node, limbs: [] };
+  const queue = [];
+  if (isBranch(node)) {
+    queue.push([node, []]);
+  } else if (isExtension(node)) {
+    if (node.path.length >= depth) {
+      const extension = node.path.length === depth ? node.child : { path: node.path.subarray(depth), child: node.child };
+      return {
+        trunk: void 0,
+        limbs: [[node.path.subarray(0, depth), extension]]
+      };
+    }
+    queue.push([node.child, [...node.path]]);
+  } else if (node.path.length >= depth) {
+    const leaf = newLeaf(node.path.subarray(depth), node.data);
+    return {
+      trunk: void 0,
+      limbs: [[node.path.subarray(0, depth), leaf]]
+    };
+  } else {
+    return { trunk: node, limbs: [] };
+  }
+  const limbs = [];
+  while (queue.length) {
+    const [parent, path] = queue.pop();
+    const rest = depth - path.length - 1;
+    parent.children.forEach((child, i) => {
+      if (!child) return;
+      if (!rest) {
+        parent.children[i] = void 0;
+        limbs.push([Uint8Array.of(...path, i), child]);
+      } else if (isBranch(child)) {
+        queue.push([child, [...path, i]]);
+      } else if (child.path.length > rest) {
+        parent.children[i] = void 0;
+        const copy = { ...child };
+        copy.path = child.path.subarray(rest);
+        limbs.push([
+          Uint8Array.of(...path, i, ...child.path.subarray(0, rest)),
+          copy
+        ]);
+      } else if (isExtension(child)) {
+        queue.push([child.child, [...path, i, ...child.path]]);
+      }
+    });
+  }
+  return { trunk: node, limbs };
+}
+function graftLimb(trunk, path, limb) {
+  if (!path.length) return limb;
+  if (!trunk) {
+    if (isBranch(limb)) {
+      return { path: path.slice(), child: limb };
+    } else {
+      const copy = { ...limb };
+      copy.path = concat(path, copy.path);
+      return copy;
+    }
+  }
+  let start = 0;
+  let index = 0;
+  let node = trunk;
+  while (index < path.length - 1) {
+    if (isBranch(node)) {
+      const child = node.children[path[index]];
+      if (!child) {
+        start = index;
+        index = path.length - 1;
+        break;
+      }
+      start = ++index;
+      node = child;
+    } else if (isExtension(node)) {
+      ++start;
+      index += node.path.length;
+      node = node.child;
+    } else {
+      break;
+    }
+  }
+  if (!isBranch(node)) throw new RangeError("invalid graft");
+  if (start === index) {
+    node.children[path[start]] = limb;
+  } else if (isBranch(limb)) {
+    node.children[path[start]] = {
+      path: path.slice(start + 1),
+      child: limb
+    };
+  } else {
+    const copy = { ...limb };
+    copy.path = concat(path.subarray(start + 1), copy.path);
+    node.children[path[start]] = copy;
+  }
+  return trunk;
+}
+export {
+  Coder,
+  EMPTY_BYTES,
+  EMPTY_LEAF,
+  MAX_SIZE,
+  clearCache,
+  concat,
+  copyNode,
+  deleteNode,
+  encodeNode,
+  extractNode,
+  findLeaf,
+  followSlot,
+  fromJSON,
+  getByteCount,
+  getLeafCount,
+  getNodeCount,
+  getNodeType,
+  getProof,
+  getRootHash,
+  graftLimb,
+  insertBytes,
+  insertLeaf,
+  isBranch,
+  isEmptyLeaf,
+  isExtension,
+  isLeaf,
+  keccak256,
+  mimcHash,
+  newBranch,
+  newLeaf,
+  pluckLimbs,
+  toBigInt,
+  toBytes,
+  toHex,
+  toJSON,
+  toNibblePath,
+  trimLeadingZeros
+};