@polkadot-api/metadata-builders 0.2.0 → 0.3.1

package/dist/index.mjs

@@ -6,8 +6,7 @@ var getLookupFn = (lookupData) => {
   const withCache2 = (fn) => {
     return (id) => {
       let entry = lookups.get(id);
-      if (entry)
-        return entry;
+      if (entry) return entry;
       if (from.has(id)) {
         const entry2 = {
           id
@@ -36,8 +35,7 @@ var getLookupFn = (lookupData) => {
   const getLookupEntryDef = withCache2((id) => {
     const { def, path, params } = lookupData[id];
     if (def.tag === "composite") {
-      if (def.value.length === 0)
-        return { type: "void" };
+      if (def.value.length === 0) return { type: "void" };
       if (def.value.length === 1) {
         const inner = getLookupEntryDef(def.value[0].type);
         if (isAccountId32SearchOn && path.at(-1) === "AccountId32" && isBytes(inner, 32)) {
@@ -90,8 +88,7 @@ var getLookupFn = (lookupData) => {
           }
         };
       }
-      if (def.value.length === 0)
-        return { type: "void" };
+      if (def.value.length === 0) return { type: "void" };
       const enumValue = {};
       const enumDocs = {};
       def.value.forEach((x) => {
@@ -118,17 +115,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",
@@ -146,10 +155,8 @@ var getLookupFn = (lookupData) => {
     if (def.tag === "array") {
       const { len } = def.value;
       const value = getLookupEntryDef(def.value.type);
-      if (len === 0)
-        return { type: "void" };
-      if (len === 1)
-        return value;
+      if (len === 0) return { type: "void" };
+      if (len === 1) return value;
       return {
         type: "array",
         value,
@@ -157,8 +164,7 @@ var getLookupFn = (lookupData) => {
       };
     }
     if (def.tag === "tuple") {
-      if (def.value.length === 0)
-        return { type: "void" };
+      if (def.value.length === 0) return { type: "void" };
       if (def.value.length === 1)
         return getLookupEntryDef(def.value[0]);
       const value = def.value.map((x) => getLookupEntryDef(x));
@@ -185,8 +191,7 @@ var getLookupFn = (lookupData) => {
     }
     if (def.tag === "compact") {
       const translated = getLookupEntryDef(def.value);
-      if (translated.type === "void")
-        return { type: "compact", isBig: null };
+      if (translated.type === "void") return { type: "compact", isBig: null };
       const isBig = Number(translated.value.slice(1)) > 32;
       return {
         type: "compact",
@@ -206,8 +211,7 @@ import * as scale from "@polkadot-api/substrate-bindings";
 // src/with-cache.ts
 var withCache = (fn, onEnterCircular, onExitCircular) => (input, cache, stack, ...rest) => {
   const { id } = input;
-  if (cache.has(id))
-    return cache.get(id);
+  if (cache.has(id)) return cache.get(id);
   if (stack.has(id)) {
     const res = onEnterCircular(() => cache.get(id), input, ...rest);
     cache.set(id, res);
@@ -226,18 +230,12 @@ var withCache = (fn, onEnterCircular, onExitCircular) => (input, cache, stack, .
 import { mapObject } from "@polkadot-api/utils";
 var _bytes = scale.Bin();
 var _buildCodec = (input, cache, stack, _accountId) => {
-  if (input.type === "primitive")
-    return scale[input.value];
-  if (input.type === "void")
-    return scale._void;
-  if (input.type === "AccountId32")
-    return _accountId;
-  if (input.type === "AccountId20")
-    return scale.ethAccount;
-  if (input.type === "compact")
-    return scale.compact;
-  if (input.type === "bitSequence")
-    return scale.bitSequence;
+  if (input.type === "primitive") return scale[input.value];
+  if (input.type === "void") return scale._void;
+  if (input.type === "AccountId32") return _accountId;
+  if (input.type === "AccountId20") return scale.ethAccount;
+  if (input.type === "compact") return scale.compact;
+  if (input.type === "bitSequence") return scale.bitSequence;
   const buildNextCodec = (nextInput) => buildCodec(nextInput, cache, stack, _accountId);
   const buildVector = (inner2, len) => {
     const innerCodec = buildNextCodec(inner2);
@@ -258,25 +256,28 @@ var _buildCodec = (input, cache, stack, _accountId) => {
       return scale.Bin(input.len);
     return buildVector(input.value, input.len);
   }
-  if (input.type === "sequence")
-    return buildVector(input.value);
-  if (input.type === "tuple")
-    return buildTuple(input.value);
-  if (input.type === "struct")
-    return buildStruct(input.value);
-  if (input.type === "option")
-    return scale.Option(buildNextCodec(input.value));
+  if (input.type === "sequence") return buildVector(input.value);
+  if (input.type === "tuple") return buildTuple(input.value);
+  if (input.type === "struct") return buildStruct(input.value);
+  if (input.type === "option") return scale.Option(buildNextCodec(input.value));
   if (input.type === "result")
     return scale.Result(
       buildNextCodec(input.value.ok),
       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) => {
@@ -329,24 +330,42 @@ var getDynamicBuilder = (metadata) => {
     const { key, value, hashers } = storageEntry.type.value;
     const val = buildDefinition(value);
     const hashes = hashers.map((x) => scale[x.tag]);
-    const hashArgs = hashes.length === 1 ? [[buildDefinition(key), hashes[0]]] : getLookupEntryDef(key).value.map(
-      (x, idx) => [
-        buildDefinition(x.id),
-        hashes[idx]
-      ]
-    );
+    const hashArgs = (() => {
+      if (hashes.length === 1) {
+        return [[buildDefinition(key), hashes[0]]];
+      }
+      const keyDef = getLookupEntryDef(key);
+      switch (keyDef.type) {
+        case "array":
+          return hashes.map((hash) => [buildDefinition(keyDef.value.id), hash]);
+        case "tuple":
+          return keyDef.value.map((x, idx) => [
+            buildDefinition(x.id),
+            hashes[idx]
+          ]);
+        default:
+          throw new Error("Invalid key type");
+      }
+    })();
     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(
-      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(
+          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);
@@ -355,8 +374,7 @@ var getDynamicBuilder = (metadata) => {
   const buildVariant = (type) => (pallet, name) => {
     const palletEntry = metadata.pallets.find((x) => x.name === pallet);
     const lookup = getLookupEntryDef(palletEntry[type]);
-    if (lookup.type !== "enum")
-      throw null;
+    if (lookup.type !== "enum") throw null;
     const entry = lookup.value[name];
     return {
       location: [palletEntry.index, entry.idx],
@@ -365,8 +383,7 @@ var getDynamicBuilder = (metadata) => {
   };
   const buildRuntimeCall = (api, method) => {
     const entry = metadata.apis.find((x) => x.name === api)?.methods.find((x) => x.name === method);
-    if (!entry)
-      throw null;
+    if (!entry) throw null;
     return {
       args: scale.Tuple(...entry.inputs.map((x) => buildDefinition(x.type))),
       value: buildDefinition(entry.output)
@@ -386,13 +403,174 @@ var getDynamicBuilder = (metadata) => {
 
 // src/checksum-builder.ts
 import { h64 } from "@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) => {
   const res = new Uint8Array(values.length * 8);
   const dv = new DataView(res.buffer);
-  for (let i = 0; i < values.length; i++)
-    dv.setBigUint64(i * 8, values[i]);
+  for (let i = 0; i < values.length; i++) dv.setBigUint64(i * 8, values[i]);
   return h64(res);
 };
 var getStringChecksum = (values) => getChecksum(values.map((v) => h64(encodeText(v))));
@@ -448,61 +626,10 @@ 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]]);
-  if (input.type === "void")
-    return getChecksum([shapeIds.void]);
+  if (input.type === "void") return getChecksum([shapeIds.void]);
   if (input.type === "compact")
     return getChecksum([
       shapeIds.primitive,
@@ -516,6 +643,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") {
@@ -525,23 +658,19 @@ 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);
-  if (input.type === "tuple")
-    return buildTuple(input.value);
-  if (input.type === "struct")
-    return buildStruct(input.value);
+  if (input.type === "tuple") return buildTuple(input.value);
+  if (input.type === "struct") return buildStruct(input.value);
   if (input.type === "option")
     return getChecksum([shapeIds.option, buildNextChecksum(input.value)]);
   if (input.type === "result")
@@ -551,8 +680,7 @@ var _buildChecksum = (input, buildNextChecksum) => {
       buildNextChecksum(input.value.ko)
     ]);
   return structLikeBuilder(shapeIds.enum, input.value, (entry) => {
-    if (entry.type === "lookupEntry")
-      return buildNextChecksum(entry.value);
+    if (entry.type === "lookupEntry") return buildNextChecksum(entry.value);
     switch (entry.type) {
       case "void":
         return getChecksum([shapeIds.void]);
@@ -560,147 +688,129 @@ 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];
-    while (toVisit.length) {
-      const idx = toVisit.pop();
-      if (!ungroupedCycles.has(idx))
-        continue;
-      ungroupedCycles.delete(idx);
-      const cycle = cycles[idx];
-      cycle.forEach((v) => group.add(Number(v)));
-      edges.get(idx).forEach((n) => toVisit.push(n));
-    }
-    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());
+    const result2 = /* @__PURE__ */ new Set();
+    const toVisit = Array.from(group);
+    while (toVisit.length) {
+      const id = toVisit.pop();
+      if (result2.has(id)) continue;
+      result2.add(id);
+      graph.get(id)?.refs.forEach((id2) => toVisit.push(id2));
+    }
+    return Array.from(result2);
   };
   const result = new Array();
   function dependentsFirst(group) {
-    if (result.includes(group))
-      return;
+    if (result.includes(group)) return;
     const dependents = groups.filter(
       (candidate) => candidate !== group && getReachableNodes(group).some((node) => candidate.has(node))
     );
     dependents.forEach((group2) => dependentsFirst(group2));
-    if (result.includes(group))
-      return;
+    if (result.includes(group)) return;
     result.push(group);
   }
   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);
@@ -717,8 +827,7 @@ var getChecksumBuilder = (metadata) => {
   const buildRuntimeCall = (api, method) => {
     try {
       const entry = metadata.apis.find((x) => x.name === api)?.methods.find((x) => x.name === method);
-      if (!entry)
-        throw null;
+      if (!entry) throw null;
       const argNamesChecksum = getStringChecksum(
         entry.inputs.map((x) => x.name)
       );
@@ -732,14 +841,20 @@ var getChecksumBuilder = (metadata) => {
     }
   };
   const buildComposite = (input) => {
-    if (input.type === "void")
-      return getChecksum([0n]);
+    if (input.type === "void") return getChecksum([0n]);
     if (input.type === "tuple") {
       const values = Object.values(input.value).map(
         (entry) => buildDefinition(entry.id)
       );
       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,
@@ -760,8 +875,7 @@ var getChecksumBuilder = (metadata) => {
         palletEntry[variantType]
       );
       buildDefinition(enumLookup.id);
-      if (enumLookup.type !== "enum")
-        throw null;
+      if (enumLookup.type !== "enum") throw null;
       const entry = enumLookup.value[name];
       return entry.type === "lookupEntry" ? buildDefinition(entry.value.id) : buildComposite(entry);
     } catch (_) {