@polkadot-api/metadata-builders 0.3.0 → 0.3.2

package/dist/index.js

@@ -38,14 +38,14 @@ module.exports = __toCommonJS(src_exports);
 
 // src/lookups.ts
 var isBytes = (value, nBytes) => value.type === "array" && value.len === nBytes && value.value.type === "primitive" && value.value.value === "u8";
+var _void = { type: "void" };
 var getLookupFn = (lookupData) => {
   const lookups = /* @__PURE__ */ new Map();
   const from = /* @__PURE__ */ new Set();
   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
@@ -74,8 +74,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 _void;
       if (def.value.length === 1) {
         const inner = getLookupEntryDef(def.value[0].type);
         if (isAccountId32SearchOn && path.at(-1) === "AccountId32" && isBytes(inner, 32)) {
@@ -88,24 +87,7 @@ var getLookupFn = (lookupData) => {
         }
         return inner;
       }
-      let allKey = true;
-      const values = {};
-      const innerDocs = {};
-      def.value.forEach((x, idx) => {
-        allKey = allKey && !!x.name;
-        const key = x.name || idx;
-        values[key] = getLookupEntryDef(x.type);
-        innerDocs[key] = x.docs;
-      });
-      return allKey ? {
-        type: "struct",
-        value: values,
-        innerDocs
-      } : {
-        type: "tuple",
-        value: Object.values(values),
-        innerDocs: Object.values(innerDocs)
-      };
+      return getComplexVar(def.value);
     }
     if (def.tag === "variant") {
       if (path.length === 1 && path[0] === "Option" && params.length === 1 && params[0].name === "T") {
@@ -128,15 +110,14 @@ var getLookupFn = (lookupData) => {
           }
         };
       }
-      if (def.value.length === 0)
-        return { type: "void" };
+      if (def.value.length === 0) return _void;
       const enumValue = {};
       const enumDocs = {};
       def.value.forEach((x) => {
         const key = x.name;
         enumDocs[key] = x.docs;
         if (x.fields.length === 0) {
-          enumValue[key] = { type: "void", idx: x.index };
+          enumValue[key] = { ..._void, idx: x.index };
           return;
         }
         if (x.fields.length === 1 && !x.fields[0].name) {
@@ -147,38 +128,7 @@ var getLookupFn = (lookupData) => {
           };
           return;
         }
-        let allKey = true;
-        const values = {};
-        const innerDocs = {};
-        x.fields.forEach((x2, idx) => {
-          allKey = allKey && !!x2.name;
-          const key2 = x2.name || idx;
-          values[key2] = getLookupEntryDef(x2.type);
-          innerDocs[key2] = x2.docs;
-        });
-        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
-          };
-        }
+        enumValue[key] = { ...getComplexVar(x.fields), idx: x.index };
       });
       return {
         type: "enum",
@@ -186,46 +136,26 @@ var getLookupFn = (lookupData) => {
         innerDocs: enumDocs
       };
     }
-    if (def.tag === "sequence") {
-      const value = getLookupEntryDef(def.value);
+    if (def.tag === "sequence")
       return {
         type: "sequence",
-        value
+        value: getLookupEntryDef(def.value)
       };
-    }
     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;
-      return {
+      return !len || value.type === "void" ? _void : len > 0 ? {
         type: "array",
         value,
         len: def.value.len
-      };
+      } : value;
     }
     if (def.tag === "tuple") {
-      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));
-      const innerDocs = def.value.map((x) => lookupData[x].docs);
-      const areAllSame = value.every((v) => v.id === value[0].id);
-      if (areAllSame && innerDocs.every((doc) => doc.length === 0)) {
-        return {
-          type: "array",
-          value: value[0],
-          len: value.length
-        };
-      }
-      return {
-        type: "tuple",
-        value,
-        innerDocs
-      };
+      if (def.value.length === 0) return _void;
+      return def.value.length > 1 ? getArrayOrTuple(
+        def.value.map((x) => getLookupEntryDef(x)),
+        def.value.map((x) => lookupData[x].docs)
+      ) : getLookupEntryDef(def.value[0]);
     }
     if (def.tag === "primitive") {
       return {
@@ -235,8 +165,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",
@@ -247,6 +176,40 @@ var getLookupFn = (lookupData) => {
       type: def.tag
     };
   });
+  const getComplexVar = (input) => {
+    let allKey = true;
+    const values = {};
+    const innerDocs = {};
+    input.forEach((x, idx) => {
+      allKey = allKey && !!x.name;
+      const key = x.name || idx;
+      const value = getLookupEntryDef(x.type);
+      if (value.type !== "void") {
+        values[key] = value;
+        innerDocs[key] = x.docs;
+      }
+    });
+    return allKey ? {
+      type: "struct",
+      value: values,
+      innerDocs
+    } : getArrayOrTuple(Object.values(values), Object.values(innerDocs));
+  };
+  const getArrayOrTuple = (values, innerDocs) => {
+    if (values.every((v) => v.id === values[0].id) && innerDocs.every((doc) => !doc.length)) {
+      const [value] = values;
+      return value.type === "void" ? _void : {
+        type: "array",
+        value: values[0],
+        len: values.length
+      };
+    }
+    return {
+      type: "tuple",
+      value: values,
+      innerDocs
+    };
+  };
   return getLookupEntryDef;
 };
 
@@ -256,8 +219,7 @@ var scale = __toESM(require("@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);
@@ -275,19 +237,17 @@ var withCache = (fn, onEnterCircular, onExitCircular) => (input, cache, stack, .
 // src/dynamic-builder.ts
 var import_utils = require("@polkadot-api/utils");
 var _bytes = scale.Bin();
+var bigCompact = scale.createCodec(
+  scale.compact[0],
+  scale.enhanceDecoder(scale.compact[1], BigInt)
+);
 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 input.isBig ? bigCompact : 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);
@@ -308,14 +268,10 @@ 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),
@@ -386,12 +342,23 @@ 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) => {
@@ -419,8 +386,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],
@@ -429,8 +395,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)
@@ -476,8 +441,7 @@ function buildLookupGraph(lookupFn, lookupLength) {
     if (i !== entry.id) {
       addEdge(i, entry.id);
     }
-    if (visited.has(entry.id))
-      continue;
+    if (visited.has(entry.id)) continue;
     visited.add(entry.id);
     switch (entry.type) {
       case "array":
@@ -522,8 +486,7 @@ function buildLookupGraph(lookupFn, lookupLength) {
 }
 var subgraphCache = /* @__PURE__ */ new WeakMap();
 function _getSubgraph(id, graph, result, cache) {
-  if (result.has(id))
-    return;
+  if (result.has(id)) return;
   const node = graph.get(id);
   result.set(id, node);
   cache.set(id, result);
@@ -535,8 +498,7 @@ function getSubgraph(id, graph) {
     subgraphCache.set(graph, /* @__PURE__ */ new Map());
   }
   const cache = subgraphCache.get(graph);
-  if (cache.has(id))
-    return cache.get(id);
+  if (cache.has(id)) return cache.get(id);
   const result = /* @__PURE__ */ new Map();
   _getSubgraph(id, graph, result, cache);
   return result;
@@ -573,8 +535,7 @@ function getStronglyConnectedComponents(graph) {
         tarjanState.get(poppedNode).onStack = false;
         component.add(poppedNode);
       } while (poppedNode !== v);
-      if (component.size > 1)
-        result.push(component);
+      if (component.size > 1) result.push(component);
     }
   }
   for (const node of graph.keys()) {
@@ -604,8 +565,7 @@ function mergeSCCsWithCommonNodes(stronglyConnectedComponents) {
     const toVisit = [ungroupedCycles.values().next().value];
     while (toVisit.length) {
       const idx = toVisit.pop();
-      if (!ungroupedCycles.has(idx))
-        continue;
+      if (!ungroupedCycles.has(idx)) continue;
       ungroupedCycles.delete(idx);
       const cycle = scc[idx];
       cycle.forEach((v) => group.add(Number(v)));
@@ -622,8 +582,7 @@ 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 (0, import_substrate_bindings.h64)(res);
 };
 var getStringChecksum = (values) => getChecksum(values.map((v) => (0, import_substrate_bindings.h64)(encodeText(v))));
@@ -682,8 +641,7 @@ var structLikeBuilder = (shapeId, input, innerChecksum) => {
 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,
@@ -723,10 +681,8 @@ var _buildChecksum = (input, buildNextChecksum) => {
   }
   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")
@@ -736,8 +692,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]);
@@ -756,8 +711,7 @@ var sortCyclicGroups = (groups, graph) => {
     const toVisit = Array.from(group);
     while (toVisit.length) {
       const id = toVisit.pop();
-      if (result2.has(id))
-        continue;
+      if (result2.has(id)) continue;
       result2.add(id);
       graph.get(id)?.refs.forEach((id2) => toVisit.push(id2));
     }
@@ -765,14 +719,12 @@ var sortCyclicGroups = (groups, graph) => {
   };
   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));
@@ -818,8 +770,7 @@ function getMirroredNodes(cyclicGroups, 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 (checksum == void 0) throw new Error("Unreachable");
     if (!checksumToNodes.has(checksum)) {
       checksumToNodes.set(checksum, []);
     }
@@ -835,8 +786,7 @@ function getMirroredNodes(cyclicGroups, graph) {
   return duplicatesMap;
 }
 var buildChecksum = (entry, cache, graph) => {
-  if (cache.has(entry.id))
-    return cache.get(entry.id);
+  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) => {
@@ -862,8 +812,7 @@ var buildChecksum = (entry, cache, graph) => {
     });
   });
   const getChecksum2 = (entry2) => {
-    if (cache.has(entry2.id))
-      return cache.get(entry2.id);
+    if (cache.has(entry2.id)) return cache.get(entry2.id);
     return _buildChecksum(entry2, getChecksum2);
   };
   return getChecksum2(entry);
@@ -890,8 +839,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)
       );
@@ -905,8 +853,7 @@ 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)
@@ -940,8 +887,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 (_) {