@ensdomains/merkle-builder 0.0.4 → 0.0.5

package/dist/index.cjs

@@ -811,89 +811,57 @@ function mimcHash(v) {
 
 // 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]]
-    };
-  }
   const limbs = [];
-  while (queue.length) {
-    const [parent, path] = queue.pop();
-    parent.children.forEach((x, i) => {
-      if (!x) return;
-      if (path.length + 1 === depth) {
-        parent.children[i] = void 0;
-        limbs.push([Uint8Array.of(...path, i), x]);
-      } else if (isBranch(x)) {
-        queue.push([x, [...path, i]]);
-      } else if (isExtension(x)) {
-        const full = [...path, i, ...x.path];
-        if (full.length >= depth) {
-          const { cache, ...branch } = x.child;
-          const child = newBranch();
-          if (cache) child.cache = cache;
-          parent.children[i] = { path: x.path, child };
-          limbs.push([new Uint8Array(full.slice(0, depth)), branch]);
-        } else {
-          queue.push([x.child, full]);
-        }
+  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 };
       }
-    });
+      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() };
+    }
   }
-  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 index = 0;
-  let parent = trunk;
-  while (index < path.length - 1) {
-    if (isBranch(parent)) {
-      parent = parent.children[path[index++]];
-    } else if (isExtension(parent)) {
-      index += parent.path.length;
-      if (index >= path.length) break;
-      parent = parent.child;
+  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;
+      }
+    } else if (isExtension(cursor)) {
+      parent = cursor;
+      part.push(...cursor.path);
+      cursor = cursor.child;
     } else {
       break;
     }
   }
-  if (isExtension(parent)) {
-    if (!isBranch(limb)) throw new RangeError("expected branch");
+  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;
-  } else if (isBranch(parent)) {
-    if (isBranch(limb)) {
-      parent.children[path[index]] = index + 1 == path.length ? limb : { path: path.slice(index + 1), child: limb };
-    } else {
-      const copy = { ...limb };
-      copy.path = concat(path.subarray(index + 1), copy.path);
-      parent.children[path[index]] = copy;
-    }
-  } else {
-    throw new RangeError("invalid graft location");
   }
   return trunk;
 }

package/dist/index.d.cts

@@ -75,10 +75,7 @@ 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): {
-    trunk: MaybeNode;
-    limbs: Limb[];
-};
+declare function pluckLimbs(node: MaybeNode, depth: number): Limb[];
 declare function graftLimb(trunk: MaybeNode, [path, limb]: Limb): Node;
 
 type Hex = `0x${string}`;

package/dist/index.d.ts

@@ -75,10 +75,7 @@ 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): {
-    trunk: MaybeNode;
-    limbs: Limb[];
-};
+declare function pluckLimbs(node: MaybeNode, depth: number): Limb[];
 declare function graftLimb(trunk: MaybeNode, [path, limb]: Limb): Node;
 
 type Hex = `0x${string}`;

package/dist/index.js

@@ -749,89 +749,57 @@ function mimcHash(v) {
 
 // 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]]
-    };
-  }
   const limbs = [];
-  while (queue.length) {
-    const [parent, path] = queue.pop();
-    parent.children.forEach((x, i) => {
-      if (!x) return;
-      if (path.length + 1 === depth) {
-        parent.children[i] = void 0;
-        limbs.push([Uint8Array.of(...path, i), x]);
-      } else if (isBranch(x)) {
-        queue.push([x, [...path, i]]);
-      } else if (isExtension(x)) {
-        const full = [...path, i, ...x.path];
-        if (full.length >= depth) {
-          const { cache, ...branch } = x.child;
-          const child = newBranch();
-          if (cache) child.cache = cache;
-          parent.children[i] = { path: x.path, child };
-          limbs.push([new Uint8Array(full.slice(0, depth)), branch]);
-        } else {
-          queue.push([x.child, full]);
-        }
+  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 };
       }
-    });
+      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() };
+    }
   }
-  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 index = 0;
-  let parent = trunk;
-  while (index < path.length - 1) {
-    if (isBranch(parent)) {
-      parent = parent.children[path[index++]];
-    } else if (isExtension(parent)) {
-      index += parent.path.length;
-      if (index >= path.length) break;
-      parent = parent.child;
+  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;
+      }
+    } else if (isExtension(cursor)) {
+      parent = cursor;
+      part.push(...cursor.path);
+      cursor = cursor.child;
     } else {
       break;
     }
   }
-  if (isExtension(parent)) {
-    if (!isBranch(limb)) throw new RangeError("expected branch");
+  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;
-  } else if (isBranch(parent)) {
-    if (isBranch(limb)) {
-      parent.children[path[index]] = index + 1 == path.length ? limb : { path: path.slice(index + 1), child: limb };
-    } else {
-      const copy = { ...limb };
-      copy.path = concat(path.subarray(index + 1), copy.path);
-      parent.children[path[index]] = copy;
-    }
-  } else {
-    throw new RangeError("invalid graft location");
   }
   return trunk;
 }

package/package.json

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