@ensdomains/merkle-builder 0.0.3 → 0.0.5

package/dist/index.cjs

@@ -404,6 +404,9 @@ var Coder = class {
     return c.pos;
   }
   pos = 0;
+  get remaining() {
+    return Math.max(0, this.buf.length - this.pos);
+  }
   reset() {
     this.pos = 0;
   }
@@ -807,96 +810,58 @@ function mimcHash(v) {
 }
 
 // src/surgery.ts
-function pluckLimbs(node, depth, exact) {
-  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]]
-    };
-  }
+function pluckLimbs(node, depth) {
   const limbs = [];
-  while (queue.length) {
-    const [parent, path] = queue.pop();
-    parent.children.forEach((child, i) => {
-      if (!child) return;
-      if (path.length + 1 === depth) {
-        parent.children[i] = void 0;
-        limbs.push([Uint8Array.of(...path, i), child]);
-      } else if (isBranch(child)) {
-        queue.push([child, [...path, i]]);
-      } else if (isExtension(child) && path.length + child.path.length <= depth) {
-        queue.push([child.child, [...path, i, ...child.path]]);
-      } else if (exact) {
-        parent.children[i] = void 0;
-        const full = [...path, i, ...child.path];
-        const rest = new Uint8Array(full.slice(depth));
-        limbs.push([
-          new Uint8Array(full.slice(0, depth)),
-          isLeaf(child) ? newLeaf(rest, child.data) : rest.length ? { path: rest, child: child.child } : child.child
-        ]);
+  if (node && depth > 0) pluck(node, []);
+  return limbs;
+  function pluck(node2, path, ext = false) {
+    if (path.length >= depth) {
+      if (ext && "cache" in node2) {
+        node2 = { children: node2.children };
       }
-    });
-  }
-  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;
+      limbs.push([new Uint8Array(path.slice(0, depth)), node2]);
+      return true;
+    } else if (isBranch(node2)) {
+      node2.children.forEach((x, i, v) => {
+        if (x && pluck(x, [...path, i])) {
+          v[i] = void 0;
+        }
+      });
+    } else if (isExtension(node2) && pluck(node2.child, [...path, ...node2.path], true)) {
+      node2.child = { ...node2.child, ...newBranch() };
     }
   }
-  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;
+}
+function graftLimb(trunk, [path, limb]) {
+  if (!trunk || !path.length) throw new Error("invalid graft");
+  let part = [];
+  let parent = void 0;
+  let cursor = trunk;
+  while (part.length < path.length) {
+    if (isBranch(cursor)) {
+      const i = path[part.length];
+      part.push(i);
+      parent = cursor;
+      cursor = cursor.children[i];
+      if (isExtension(cursor)) {
+        parent = cursor;
+        part.push(...cursor.path);
+        cursor = cursor.child;
       }
-      start = ++index;
-      node = child;
-    } else if (isExtension(node)) {
-      ++start;
-      index += node.path.length;
-      node = node.child;
+    } else if (isExtension(cursor)) {
+      parent = cursor;
+      part.push(...cursor.path);
+      cursor = cursor.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;
+  if (!path.every((x, i) => x === part[i])) throw new Error("invalid path");
+  if (isBranch(parent)) {
+    parent.children[path[path.length - 1]] = limb;
+  } else if (isExtension(parent)) {
+    if (!isBranch(limb)) throw new Error("invalid limb");
+    parent.child.children = limb.children;
   }
   return trunk;
 }

package/dist/index.d.cts

@@ -41,6 +41,7 @@ declare class Coder {
     static getByteCount(node: MaybeNode): number;
     pos: number;
     constructor(buf?: Uint8Array);
+    get remaining(): number;
     reset(): void;
     expand(need: number): void;
     require(need: number): void;
@@ -74,11 +75,8 @@ declare function insertBytes(node: MaybeNode, slot: Uint8Array, value: Uint8Arra
 declare function mimcHash(v: bigint[]): bigint;
 
 type Limb = [path: Uint8Array, node: Node];
-declare function pluckLimbs(node: MaybeNode, depth: number, exact?: boolean): {
-    trunk: MaybeNode;
-    limbs: Limb[];
-};
-declare function graftLimb(trunk: MaybeNode, path: Uint8Array, limb: Node): Node;
+declare function pluckLimbs(node: MaybeNode, depth: number): Limb[];
+declare function graftLimb(trunk: MaybeNode, [path, limb]: Limb): Node;
 
 type Hex = `0x${string}`;
 declare function keccak256(v: Uint8Array): Uint8Array;

package/dist/index.d.ts

@@ -41,6 +41,7 @@ declare class Coder {
     static getByteCount(node: MaybeNode): number;
     pos: number;
     constructor(buf?: Uint8Array);
+    get remaining(): number;
     reset(): void;
     expand(need: number): void;
     require(need: number): void;
@@ -74,11 +75,8 @@ declare function insertBytes(node: MaybeNode, slot: Uint8Array, value: Uint8Arra
 declare function mimcHash(v: bigint[]): bigint;
 
 type Limb = [path: Uint8Array, node: Node];
-declare function pluckLimbs(node: MaybeNode, depth: number, exact?: boolean): {
-    trunk: MaybeNode;
-    limbs: Limb[];
-};
-declare function graftLimb(trunk: MaybeNode, path: Uint8Array, limb: Node): Node;
+declare function pluckLimbs(node: MaybeNode, depth: number): Limb[];
+declare function graftLimb(trunk: MaybeNode, [path, limb]: Limb): Node;
 
 type Hex = `0x${string}`;
 declare function keccak256(v: Uint8Array): Uint8Array;

package/dist/index.js

@@ -342,6 +342,9 @@ var Coder = class {
     return c.pos;
   }
   pos = 0;
+  get remaining() {
+    return Math.max(0, this.buf.length - this.pos);
+  }
   reset() {
     this.pos = 0;
   }
@@ -745,96 +748,58 @@ function mimcHash(v) {
 }
 
 // src/surgery.ts
-function pluckLimbs(node, depth, exact) {
-  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]]
-    };
-  }
+function pluckLimbs(node, depth) {
   const limbs = [];
-  while (queue.length) {
-    const [parent, path] = queue.pop();
-    parent.children.forEach((child, i) => {
-      if (!child) return;
-      if (path.length + 1 === depth) {
-        parent.children[i] = void 0;
-        limbs.push([Uint8Array.of(...path, i), child]);
-      } else if (isBranch(child)) {
-        queue.push([child, [...path, i]]);
-      } else if (isExtension(child) && path.length + child.path.length <= depth) {
-        queue.push([child.child, [...path, i, ...child.path]]);
-      } else if (exact) {
-        parent.children[i] = void 0;
-        const full = [...path, i, ...child.path];
-        const rest = new Uint8Array(full.slice(depth));
-        limbs.push([
-          new Uint8Array(full.slice(0, depth)),
-          isLeaf(child) ? newLeaf(rest, child.data) : rest.length ? { path: rest, child: child.child } : child.child
-        ]);
+  if (node && depth > 0) pluck(node, []);
+  return limbs;
+  function pluck(node2, path, ext = false) {
+    if (path.length >= depth) {
+      if (ext && "cache" in node2) {
+        node2 = { children: node2.children };
       }
-    });
-  }
-  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;
+      limbs.push([new Uint8Array(path.slice(0, depth)), node2]);
+      return true;
+    } else if (isBranch(node2)) {
+      node2.children.forEach((x, i, v) => {
+        if (x && pluck(x, [...path, i])) {
+          v[i] = void 0;
+        }
+      });
+    } else if (isExtension(node2) && pluck(node2.child, [...path, ...node2.path], true)) {
+      node2.child = { ...node2.child, ...newBranch() };
     }
   }
-  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;
+}
+function graftLimb(trunk, [path, limb]) {
+  if (!trunk || !path.length) throw new Error("invalid graft");
+  let part = [];
+  let parent = void 0;
+  let cursor = trunk;
+  while (part.length < path.length) {
+    if (isBranch(cursor)) {
+      const i = path[part.length];
+      part.push(i);
+      parent = cursor;
+      cursor = cursor.children[i];
+      if (isExtension(cursor)) {
+        parent = cursor;
+        part.push(...cursor.path);
+        cursor = cursor.child;
       }
-      start = ++index;
-      node = child;
-    } else if (isExtension(node)) {
-      ++start;
-      index += node.path.length;
-      node = node.child;
+    } else if (isExtension(cursor)) {
+      parent = cursor;
+      part.push(...cursor.path);
+      cursor = cursor.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;
+  if (!path.every((x, i) => x === part[i])) throw new Error("invalid path");
+  if (isBranch(parent)) {
+    parent.children[path[path.length - 1]] = limb;
+  } else if (isExtension(parent)) {
+    if (!isBranch(limb)) throw new Error("invalid limb");
+    parent.child.children = limb.children;
   }
   return trunk;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ensdomains/merkle-builder",
-	"version": "0.0.3",
+	"version": "0.0.5",
 	"description": "Low-level Merkle-Patricia storage trie implementation",
 	"type": "module",
 	"main": "dist/index.cjs",