@polkadot-api/metadata-builders 0.1.0 → 0.3.0

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import * as scale from '@polkadot-api/substrate-bindings';
-import { StringRecord, V15, Codec } from '@polkadot-api/substrate-bindings';
+import { StringRecord, V14, V15, Codec } from '@polkadot-api/substrate-bindings';
 
 type MetadataPrimitives = "bool" | "char" | "str" | "u8" | "u16" | "u32" | "u64" | "u128" | "u256" | "i8" | "i16" | "i32" | "i64" | "i128" | "i256";
 type PrimitiveVar = {
@@ -38,7 +38,7 @@ type EnumVar = {
     value: StringRecord<({
         type: "lookupEntry";
         value: LookupEntry;
-    } | VoidVar | TupleVar | StructVar) & {
+    } | VoidVar | TupleVar | StructVar | ArrayVar) & {
         idx: number;
     }>;
     innerDocs: StringRecord<string[]>;
@@ -169,7 +169,7 @@ declare const getLookupFn: (lookupData: {
     docs: string[];
 }[]) => (id: number) => LookupEntry;
 
-declare const getDynamicBuilder: (metadata: V15) => {
+declare const getDynamicBuilder: (metadata: V14 | V15) => {
     buildDefinition: (id: number) => Codec<any>;
     buildStorage: (pallet: string, entry: string) => {
         len: number;
@@ -207,7 +207,7 @@ declare const getDynamicBuilder: (metadata: V15) => {
     ss58Prefix: number | undefined;
 };
 
-declare const getChecksumBuilder: (metadata: V15) => {
+declare const getChecksumBuilder: (metadata: V14 | V15) => {
     buildDefinition: (id: number) => string | null;
     buildRuntimeCall: (api: string, method: string) => string | null;
     buildStorage: (pallet: string, entry: string) => string | null;
@@ -215,7 +215,7 @@ declare const getChecksumBuilder: (metadata: V15) => {
     buildEvent: (pallet: string, name: string) => string | null;
     buildError: (pallet: string, name: string) => string | null;
     buildConstant: (pallet: string, constantName: string) => string | null;
-    buildComposite: (input: VoidVar | TupleVar | StructVar) => string | null;
+    buildComposite: (input: VoidVar | TupleVar | StructVar | ArrayVar) => string | null;
     buildNamedTuple: (input: StructVar) => string | null;
     getAllGeneratedChecksums: () => string[];
 };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as scale from '@polkadot-api/substrate-bindings';
-import { StringRecord, V15, Codec } from '@polkadot-api/substrate-bindings';
+import { StringRecord, V14, V15, Codec } from '@polkadot-api/substrate-bindings';
 
 type MetadataPrimitives = "bool" | "char" | "str" | "u8" | "u16" | "u32" | "u64" | "u128" | "u256" | "i8" | "i16" | "i32" | "i64" | "i128" | "i256";
 type PrimitiveVar = {
@@ -38,7 +38,7 @@ type EnumVar = {
     value: StringRecord<({
         type: "lookupEntry";
         value: LookupEntry;
-    } | VoidVar | TupleVar | StructVar) & {
+    } | VoidVar | TupleVar | StructVar | ArrayVar) & {
         idx: number;
     }>;
     innerDocs: StringRecord<string[]>;
@@ -169,7 +169,7 @@ declare const getLookupFn: (lookupData: {
     docs: string[];
 }[]) => (id: number) => LookupEntry;
 
-declare const getDynamicBuilder: (metadata: V15) => {
+declare const getDynamicBuilder: (metadata: V14 | V15) => {
     buildDefinition: (id: number) => Codec<any>;
     buildStorage: (pallet: string, entry: string) => {
         len: number;
@@ -207,7 +207,7 @@ declare const getDynamicBuilder: (metadata: V15) => {
     ss58Prefix: number | undefined;
 };
 
-declare const getChecksumBuilder: (metadata: V15) => {
+declare const getChecksumBuilder: (metadata: V14 | V15) => {
     buildDefinition: (id: number) => string | null;
     buildRuntimeCall: (api: string, method: string) => string | null;
     buildStorage: (pallet: string, entry: string) => string | null;
@@ -215,7 +215,7 @@ declare const getChecksumBuilder: (metadata: V15) => {
     buildEvent: (pallet: string, name: string) => string | null;
     buildError: (pallet: string, name: string) => string | null;
     buildConstant: (pallet: string, constantName: string) => string | null;
-    buildComposite: (input: VoidVar | TupleVar | StructVar) => string | null;
+    buildComposite: (input: VoidVar | TupleVar | StructVar | ArrayVar) => string | null;
     buildNamedTuple: (input: StructVar) => string | null;
     getAllGeneratedChecksums: () => string[];
 };

package/dist/index.js

@@ -156,17 +156,29 @@ var getLookupFn = (lookupData) => {
           values[key2] = getLookupEntryDef(x2.type);
           innerDocs[key2] = x2.docs;
         });
-        enumValue[key] = allKey ? {
-          type: "struct",
-          value: values,
-          innerDocs,
-          idx: x.index
-        } : {
-          type: "tuple",
-          value: Object.values(values),
-          innerDocs: Object.values(innerDocs),
-          idx: x.index
-        };
+        if (allKey) {
+          enumValue[key] = {
+            type: "struct",
+            value: values,
+            innerDocs,
+            idx: x.index
+          };
+        } else {
+          const valuesArr = Object.values(values);
+          const innerDocsArr = Object.values(innerDocs);
+          const areAllSame = valuesArr.every((v) => v.id === valuesArr[0].id);
+          enumValue[key] = areAllSame && innerDocsArr.every((doc) => doc.length === 0) ? {
+            type: "array",
+            value: valuesArr[0],
+            len: valuesArr.length,
+            idx: x.index
+          } : {
+            type: "tuple",
+            value: valuesArr,
+            innerDocs: innerDocsArr,
+            idx: x.index
+          };
+        }
       });
       return {
         type: "enum",
@@ -310,11 +322,18 @@ var _buildCodec = (input, cache, stack, _accountId) => {
       buildNextCodec(input.value.ko)
     );
   const dependencies = Object.values(input.value).map((v) => {
-    if (v.type === "void")
-      return scale._void;
-    if (v.type === "lookupEntry")
-      return buildNextCodec(v.value);
-    return v.type === "tuple" ? buildTuple(v.value) : buildStruct(v.value);
+    switch (v.type) {
+      case "void":
+        return scale._void;
+      case "lookupEntry":
+        return buildNextCodec(v.value);
+      case "tuple":
+        return buildTuple(v.value);
+      case "struct":
+        return buildStruct(v.value);
+      case "array":
+        return buildVector(v.value, v.len);
+    }
   });
   const inner = Object.fromEntries(
     Object.keys(input.value).map((key, idx) => {
@@ -376,15 +395,22 @@ var getDynamicBuilder = (metadata) => {
     return storageWithFallback(hashes.length, entry, val.dec, ...hashArgs);
   };
   const buildEnumEntry = (entry) => {
-    if (entry.type === "void")
-      return scale._void;
-    if (entry.type === "lookupEntry")
-      return buildDefinition(entry.value.id);
-    return entry.type === "tuple" ? scale.Tuple(
-      ...Object.values(entry.value).map((l) => buildDefinition(l.id))
-    ) : scale.Struct(
-      (0, import_utils.mapObject)(entry.value, (x) => buildDefinition(x.id))
-    );
+    switch (entry.type) {
+      case "void":
+        return scale._void;
+      case "lookupEntry":
+        return buildDefinition(entry.value.id);
+      case "tuple":
+        return scale.Tuple(
+          ...Object.values(entry.value).map((l) => buildDefinition(l.id))
+        );
+      case "struct":
+        return scale.Struct(
+          (0, import_utils.mapObject)(entry.value, (x) => buildDefinition(x.id))
+        );
+      case "array":
+        return scale.Vector(buildDefinition(entry.value.id), entry.len);
+    }
   };
   const buildConstant = (pallet, constantName) => {
     const storageEntry = metadata.pallets.find((x) => x.name === pallet).constants.find((s) => s.name === constantName);
@@ -424,6 +450,173 @@ var getDynamicBuilder = (metadata) => {
 
 // src/checksum-builder.ts
 var import_substrate_bindings = require("@polkadot-api/substrate-bindings");
+
+// src/lookup-graph.ts
+function buildLookupGraph(lookupFn, lookupLength) {
+  const result = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  const addEdge = (from, to) => {
+    if (!result.has(from))
+      result.set(from, {
+        entry: lookupFn(from),
+        backRefs: /* @__PURE__ */ new Set(),
+        refs: /* @__PURE__ */ new Set()
+      });
+    if (!result.has(to))
+      result.set(to, {
+        entry: lookupFn(to),
+        backRefs: /* @__PURE__ */ new Set(),
+        refs: /* @__PURE__ */ new Set()
+      });
+    result.get(from).refs.add(to);
+    result.get(to).backRefs.add(from);
+  };
+  for (let i = 0; i < lookupLength; i++) {
+    const entry = lookupFn(i);
+    if (i !== entry.id) {
+      addEdge(i, entry.id);
+    }
+    if (visited.has(entry.id))
+      continue;
+    visited.add(entry.id);
+    switch (entry.type) {
+      case "array":
+      case "option":
+      case "sequence":
+        addEdge(entry.id, entry.value.id);
+        break;
+      case "enum":
+        Object.values(entry.value).forEach((enumEntry) => {
+          switch (enumEntry.type) {
+            case "array":
+            case "lookupEntry":
+              addEdge(entry.id, enumEntry.value.id);
+              break;
+            case "struct":
+            case "tuple":
+              Object.values(enumEntry.value).forEach(
+                (v) => addEdge(entry.id, v.id)
+              );
+              break;
+          }
+        });
+        break;
+      case "result":
+        addEdge(entry.id, entry.value.ok.id);
+        addEdge(entry.id, entry.value.ko.id);
+        break;
+      case "struct":
+      case "tuple":
+        Object.values(entry.value).forEach((v) => addEdge(entry.id, v.id));
+        break;
+    }
+    if (!result.has(entry.id)) {
+      result.set(entry.id, {
+        backRefs: /* @__PURE__ */ new Set(),
+        refs: /* @__PURE__ */ new Set(),
+        entry
+      });
+    }
+  }
+  return result;
+}
+var subgraphCache = /* @__PURE__ */ new WeakMap();
+function _getSubgraph(id, graph, result, cache) {
+  if (result.has(id))
+    return;
+  const node = graph.get(id);
+  result.set(id, node);
+  cache.set(id, result);
+  node.refs.forEach((ref) => _getSubgraph(ref, graph, result, cache));
+  node.backRefs.forEach((ref) => _getSubgraph(ref, graph, result, cache));
+}
+function getSubgraph(id, graph) {
+  if (!subgraphCache.has(graph)) {
+    subgraphCache.set(graph, /* @__PURE__ */ new Map());
+  }
+  const cache = subgraphCache.get(graph);
+  if (cache.has(id))
+    return cache.get(id);
+  const result = /* @__PURE__ */ new Map();
+  _getSubgraph(id, graph, result, cache);
+  return result;
+}
+function getStronglyConnectedComponents(graph) {
+  const tarjanState = /* @__PURE__ */ new Map();
+  let index = 0;
+  const stack = [];
+  const result = [];
+  function strongConnect(v) {
+    const state = {
+      index,
+      lowLink: index,
+      onStack: true
+    };
+    tarjanState.set(v, state);
+    index++;
+    stack.push(v);
+    const edges = graph.get(v).refs;
+    for (let w of edges) {
+      const edgeState = tarjanState.get(w);
+      if (!edgeState) {
+        strongConnect(w);
+        state.lowLink = Math.min(state.lowLink, tarjanState.get(w).lowLink);
+      } else if (edgeState.onStack) {
+        state.lowLink = Math.min(state.lowLink, edgeState.index);
+      }
+    }
+    if (state.lowLink === state.index) {
+      const component = /* @__PURE__ */ new Set();
+      let poppedNode = -1;
+      do {
+        poppedNode = stack.pop();
+        tarjanState.get(poppedNode).onStack = false;
+        component.add(poppedNode);
+      } while (poppedNode !== v);
+      if (component.size > 1)
+        result.push(component);
+    }
+  }
+  for (const node of graph.keys()) {
+    if (!tarjanState.has(node)) {
+      strongConnect(node);
+    }
+  }
+  return result;
+}
+function mergeSCCsWithCommonNodes(stronglyConnectedComponents) {
+  const scc = stronglyConnectedComponents;
+  const ungroupedCycles = new Set(scc.map((_, i) => i));
+  const edges = new Map(scc.map((_, i) => [i, /* @__PURE__ */ new Set()]));
+  scc.forEach((cycle, i) => {
+    scc.slice(i + 1).forEach((otherCycle, _j) => {
+      const j = _j + i + 1;
+      const combined = /* @__PURE__ */ new Set([...cycle, ...otherCycle]);
+      if (combined.size !== cycle.size + otherCycle.size) {
+        edges.get(i).add(j);
+        edges.get(j).add(i);
+      }
+    });
+  });
+  const groups = [];
+  while (ungroupedCycles.size) {
+    const group = /* @__PURE__ */ new Set();
+    const toVisit = [ungroupedCycles.values().next().value];
+    while (toVisit.length) {
+      const idx = toVisit.pop();
+      if (!ungroupedCycles.has(idx))
+        continue;
+      ungroupedCycles.delete(idx);
+      const cycle = scc[idx];
+      cycle.forEach((v) => group.add(Number(v)));
+      edges.get(idx).forEach((n) => toVisit.push(n));
+    }
+    groups.push(group);
+  }
+  return groups;
+}
+
+// src/checksum-builder.ts
 var textEncoder = new TextEncoder();
 var encodeText = textEncoder.encode.bind(textEncoder);
 var getChecksum = (values) => {
@@ -486,56 +679,6 @@ var structLikeBuilder = (shapeId, input, innerChecksum) => {
   );
   return getChecksum([shapeId, keysChecksum, valuesChecksum]);
 };
-var buildGraph = (entry, result = /* @__PURE__ */ new Map()) => {
-  if (result.has(entry.id))
-    return result;
-  switch (entry.type) {
-    case "array":
-    case "option":
-    case "sequence":
-      result.set(entry.id, [entry, /* @__PURE__ */ new Set([entry.value.id])]);
-      buildGraph(entry.value, result);
-      break;
-    case "enum": {
-      const children = Object.values(entry.value).flatMap((value) => {
-        if (value.type === "void")
-          return [];
-        if (value.type === "lookupEntry")
-          return value.value;
-        if (value.type === "struct")
-          return Object.values(value.value);
-        return value.value;
-      });
-      result.set(entry.id, [entry, new Set(children.map((child) => child.id))]);
-      children.forEach((child) => buildGraph(child, result));
-      break;
-    }
-    case "result":
-      result.set(entry.id, [
-        entry,
-        /* @__PURE__ */ new Set([entry.value.ok.id, entry.value.ko.id])
-      ]);
-      buildGraph(entry.value.ok, result);
-      buildGraph(entry.value.ko, result);
-      break;
-    case "struct": {
-      const children = Object.values(entry.value);
-      result.set(entry.id, [entry, new Set(children.map((child) => child.id))]);
-      children.forEach((child) => buildGraph(child, result));
-      break;
-    }
-    case "tuple":
-      result.set(entry.id, [
-        entry,
-        new Set(entry.value.map((child) => child.id))
-      ]);
-      entry.value.forEach((child) => buildGraph(child, result));
-      break;
-    default:
-      result.set(entry.id, [entry, /* @__PURE__ */ new Set()]);
-  }
-  return result;
-};
 var _buildChecksum = (input, buildNextChecksum) => {
   if (input.type === "primitive")
     return getChecksum([shapeIds.primitive, metadataPrimitiveIds[input.value]]);
@@ -554,6 +697,12 @@ var _buildChecksum = (input, buildNextChecksum) => {
   if (input.type === "AccountId20") {
     return getChecksum([shapeIds.primitive, runtimePrimitiveIds.accountId20]);
   }
+  const buildVector = (entry, length) => {
+    const innerChecksum = buildNextChecksum(entry);
+    return getChecksum(
+      length !== void 0 ? [shapeIds.vector, innerChecksum, BigInt(length)] : [shapeIds.vector, innerChecksum]
+    );
+  };
   if (input.type === "array") {
     const innerValue = input.value;
     if (innerValue.type === "primitive" && innerValue.value === "u8") {
@@ -563,16 +712,14 @@ var _buildChecksum = (input, buildNextChecksum) => {
         BigInt(input.len)
       ]);
     }
-    const innerChecksum = buildNextChecksum(innerValue);
-    return getChecksum([shapeIds.vector, innerChecksum, BigInt(input.len)]);
+    return buildVector(innerValue, input.len);
   }
   if (input.type === "sequence") {
     const innerValue = input.value;
     if (innerValue.type === "primitive" && innerValue.value === "u8") {
       return getChecksum([shapeIds.primitive, runtimePrimitiveIds.byteSequence]);
     }
-    const innerChecksum = buildNextChecksum(innerValue);
-    return getChecksum([shapeIds.vector, innerChecksum]);
+    return buildVector(innerValue);
   }
   const buildTuple = (entries) => getChecksum([shapeIds.tuple, ...entries.map(buildNextChecksum)]);
   const buildStruct = (entries) => structLikeBuilder(shapeIds.struct, entries, buildNextChecksum);
@@ -598,87 +745,23 @@ var _buildChecksum = (input, buildNextChecksum) => {
         return buildTuple(entry.value);
       case "struct":
         return buildStruct(entry.value);
+      case "array":
+        return buildVector(entry.value, entry.len);
     }
   });
 };
-var getCycles = (graph) => {
-  const tarjanState = /* @__PURE__ */ new Map();
-  let index = 0;
-  const stack = [];
-  const result = [];
-  function strongConnect(v) {
-    const state = {
-      index,
-      lowLink: index,
-      onStack: true
-    };
-    tarjanState.set(v, state);
-    index++;
-    stack.push(v);
-    const edges = graph.get(v)[1];
-    for (let w of edges) {
-      const edgeState = tarjanState.get(w);
-      if (!edgeState) {
-        strongConnect(w);
-        state.lowLink = Math.min(state.lowLink, tarjanState.get(w).lowLink);
-      } else if (edgeState.onStack) {
-        state.lowLink = Math.min(state.lowLink, edgeState.index);
-      }
-    }
-    if (state.lowLink === state.index) {
-      const component = /* @__PURE__ */ new Set();
-      let poppedNode = -1;
-      do {
-        poppedNode = stack.pop();
-        tarjanState.get(poppedNode).onStack = false;
-        component.add(poppedNode);
-      } while (poppedNode !== v);
-      if (component.size > 1)
-        result.push(component);
-    }
-  }
-  for (const node of graph.keys()) {
-    if (!tarjanState.has(node)) {
-      strongConnect(node);
-    }
-  }
-  return result;
-};
-var getCyclicGroups = (cycles) => {
-  const ungroupedCycles = new Set(cycles.map((_, i) => i));
-  const edges = new Map(cycles.map((_, i) => [i, /* @__PURE__ */ new Set()]));
-  cycles.forEach((cycle, i) => {
-    cycles.slice(i + 1).forEach((otherCycle, _j) => {
-      const j = _j + i + 1;
-      const combined = /* @__PURE__ */ new Set([...cycle, ...otherCycle]);
-      if (combined.size !== cycle.size + otherCycle.size) {
-        edges.get(i).add(j);
-        edges.get(j).add(i);
-      }
-    });
-  });
-  const groups = [];
-  while (ungroupedCycles.size) {
-    const group = /* @__PURE__ */ new Set();
-    const toVisit = [ungroupedCycles.values().next().value];
+var sortCyclicGroups = (groups, graph) => {
+  const getReachableNodes = (group) => {
+    const result2 = /* @__PURE__ */ new Set();
+    const toVisit = Array.from(group);
     while (toVisit.length) {
-      const idx = toVisit.pop();
-      if (!ungroupedCycles.has(idx))
+      const id = toVisit.pop();
+      if (result2.has(id))
         continue;
-      ungroupedCycles.delete(idx);
-      const cycle = cycles[idx];
-      cycle.forEach((v) => group.add(Number(v)));
-      edges.get(idx).forEach((n) => toVisit.push(n));
+      result2.add(id);
+      graph.get(id)?.refs.forEach((id2) => toVisit.push(id2));
     }
-    groups.push(group);
-  }
-  return groups;
-};
-var sortCyclicGroups = (groups, graph) => {
-  const getReachableNodes = (group) => {
-    const first = group.values().next().value;
-    const entry = graph.get(first)[0];
-    return Array.from(buildGraph(entry).keys());
+    return Array.from(result2);
   };
   const result = new Array();
   function dependentsFirst(group) {
@@ -695,50 +778,102 @@ var sortCyclicGroups = (groups, graph) => {
   groups.forEach((group) => dependentsFirst(group));
   return result;
 };
-var buildChecksum = (entry, cache) => {
-  if (cache.has(entry.id))
-    return cache.get(entry.id);
-  const graph = buildGraph(entry);
-  const cycles = getCycles(graph);
-  const cyclicGroups = getCyclicGroups(cycles);
-  const sortedCyclicGroups = sortCyclicGroups(cyclicGroups, graph);
-  const recursiveBuildChecksum = (entry2, writeCache, skipCache = false) => {
-    if (!skipCache && cache.has(entry2.id)) {
-      return cache.get(entry2.id);
+function iterateChecksums(group, iterations, cache, graph) {
+  const groupReadCache = new Map([...group].map((id) => [id, 0n]));
+  const groupWriteCache = /* @__PURE__ */ new Map();
+  const recursiveBuildChecksum = (entry, skipCache = true) => {
+    if (!skipCache && (groupReadCache.has(entry.id) || cache.has(entry.id))) {
+      return groupReadCache.get(entry.id) ?? cache.get(entry.id);
     }
     const result = _buildChecksum(
-      entry2,
-      (nextEntry) => recursiveBuildChecksum(nextEntry, writeCache)
+      entry,
+      (nextEntry) => recursiveBuildChecksum(nextEntry, false)
     );
-    writeCache(entry2.id, result);
+    if (group.has(entry.id)) {
+      groupWriteCache.set(entry.id, result);
+    } else {
+      cache.set(entry.id, result);
+    }
     return result;
   };
+  for (let i = 0; i < iterations; i++) {
+    group.forEach((id) => recursiveBuildChecksum(graph.get(id).entry));
+    group.forEach((id) => groupReadCache.set(id, groupWriteCache.get(id)));
+  }
+  return groupReadCache;
+}
+function getMirroredNodes(cyclicGroups, graph) {
+  const maxSize = cyclicGroups.reduce(
+    (acc, group) => Math.max(acc, group.size),
+    0
+  );
+  const allEntries = new Set([...graph.values()].map((v) => v.entry.id));
+  const resultingChecksums = iterateChecksums(
+    allEntries,
+    maxSize,
+    // Cache won't be used, since it's using the internal one for every node.
+    /* @__PURE__ */ new Map(),
+    graph
+  );
+  const checksumToNodes = /* @__PURE__ */ new Map();
+  for (const id of allEntries) {
+    const checksum = resultingChecksums.get(id);
+    if (checksum == void 0)
+      throw new Error("Unreachable");
+    if (!checksumToNodes.has(checksum)) {
+      checksumToNodes.set(checksum, []);
+    }
+    checksumToNodes.get(checksum).push(id);
+  }
+  const checksumsWithDuplicates = [...checksumToNodes.entries()].filter(
+    ([, nodes]) => nodes.length > 1
+  );
+  const duplicatesMap = {};
+  checksumsWithDuplicates.forEach(([, nodes]) => {
+    nodes.forEach((n) => duplicatesMap[n] = nodes);
+  });
+  return duplicatesMap;
+}
+var buildChecksum = (entry, cache, graph) => {
+  if (cache.has(entry.id))
+    return cache.get(entry.id);
+  const subGraph = getSubgraph(entry.id, graph);
+  const cycles = getStronglyConnectedComponents(subGraph);
+  const cyclicGroups = mergeSCCsWithCommonNodes(cycles).filter((group) => {
+    return !cache.has(group.values().next().value);
+  });
+  const mirrored = getMirroredNodes(cyclicGroups, subGraph);
+  const sortedCyclicGroups = sortCyclicGroups(
+    cyclicGroups.filter((group) => group.size > 1),
+    subGraph
+  );
   sortedCyclicGroups.forEach((group) => {
-    group.forEach((id) => cache.set(id, 0n));
-    for (let i = 0; i < group.size; i++) {
-      const results = /* @__PURE__ */ new Map();
-      group.forEach(
-        (id) => recursiveBuildChecksum(
-          graph.get(id)[0],
-          (id2, value) => {
-            const writeCache = group.has(id2) ? results : cache;
-            writeCache.set(id2, value);
-          },
-          true
-        )
-      );
-      Array.from(results.entries()).forEach(
-        ([id, checksum]) => cache.set(id, checksum)
-      );
+    if (cache.has(group.values().next().value)) {
+      return;
     }
+    const result = iterateChecksums(group, group.size, cache, graph);
+    group.forEach((id) => {
+      const checksum = result.get(id);
+      if (id in mirrored) {
+        mirrored[id].forEach((id2) => cache.set(id2, checksum));
+      } else {
+        cache.set(id, checksum);
+      }
+    });
   });
-  return recursiveBuildChecksum(entry, (id, value) => cache.set(id, value));
+  const getChecksum2 = (entry2) => {
+    if (cache.has(entry2.id))
+      return cache.get(entry2.id);
+    return _buildChecksum(entry2, getChecksum2);
+  };
+  return getChecksum2(entry);
 };
 var getChecksumBuilder = (metadata) => {
   const lookupData = metadata.lookup;
   const getLookupEntryDef = getLookupFn(lookupData);
+  const graph = buildLookupGraph(getLookupEntryDef, lookupData.length);
   const cache = /* @__PURE__ */ new Map();
-  const buildDefinition = (id) => buildChecksum(getLookupEntryDef(id), cache);
+  const buildDefinition = (id) => buildChecksum(getLookupEntryDef(id), cache, graph);
   const buildStorage = (pallet, entry) => {
     try {
       const storageEntry = metadata.pallets.find((x) => x.name === pallet).storage.items.find((s) => s.name === entry);
@@ -778,6 +913,13 @@ var getChecksumBuilder = (metadata) => {
       );
       return getChecksum([shapeIds.tuple, ...values]);
     }
+    if (input.type === "array") {
+      return getChecksum([
+        shapeIds.vector,
+        buildDefinition(input.value.id),
+        BigInt(input.len)
+      ]);
+    }
     return structLikeBuilder(
       shapeIds.struct,
       input.value,