@polkadot-api/merkleize-metadata 1.0.0

package/dist/index.js

@@ -0,0 +1,629 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  extraInfo: () => extraInfo,
+  extrinsicMetadata: () => extrinsicMetadata,
+  hash: () => hash,
+  lookup: () => lookup,
+  lookupType: () => lookupType,
+  merkleizeMetadata: () => merkleizeMetadata,
+  proof: () => proof
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/main.ts
+var import_substrate_bindings4 = require("@polkadot-api/substrate-bindings");
+
+// src/codecs.ts
+var import_substrate_bindings = require("@polkadot-api/substrate-bindings");
+var extraInfoInner = {
+  specVersion: import_substrate_bindings.u32,
+  specName: import_substrate_bindings.str,
+  base58Prefix: import_substrate_bindings.u16,
+  decimals: import_substrate_bindings.u8,
+  tokenSymbol: import_substrate_bindings.str
+};
+var extraInfo = (0, import_substrate_bindings.Struct)(extraInfoInner);
+var hash = (0, import_substrate_bindings.Bytes)(32);
+var metadataDigest = (0, import_substrate_bindings.ScaleEnum)({
+  V0: import_substrate_bindings._void,
+  V1: (0, import_substrate_bindings.Struct)({
+    typeInformationTreeRoot: hash,
+    extrinsicMetadataHash: hash,
+    ...extraInfoInner
+  })
+});
+var scalePrimitive = (0, import_substrate_bindings.ScaleEnum)({
+  bool: import_substrate_bindings._void,
+  char: import_substrate_bindings._void,
+  str: import_substrate_bindings._void,
+  u8: import_substrate_bindings._void,
+  u16: import_substrate_bindings._void,
+  u32: import_substrate_bindings._void,
+  u64: import_substrate_bindings._void,
+  u128: import_substrate_bindings._void,
+  u256: import_substrate_bindings._void,
+  i8: import_substrate_bindings._void,
+  i16: import_substrate_bindings._void,
+  i32: import_substrate_bindings._void,
+  i64: import_substrate_bindings._void,
+  i128: import_substrate_bindings._void,
+  i256: import_substrate_bindings._void
+});
+var typeRef = (0, import_substrate_bindings.ScaleEnum)({
+  bool: import_substrate_bindings._void,
+  char: import_substrate_bindings._void,
+  str: import_substrate_bindings._void,
+  u8: import_substrate_bindings._void,
+  u16: import_substrate_bindings._void,
+  u32: import_substrate_bindings._void,
+  u64: import_substrate_bindings._void,
+  u128: import_substrate_bindings._void,
+  u256: import_substrate_bindings._void,
+  i8: import_substrate_bindings._void,
+  i16: import_substrate_bindings._void,
+  i32: import_substrate_bindings._void,
+  i64: import_substrate_bindings._void,
+  i128: import_substrate_bindings._void,
+  i256: import_substrate_bindings._void,
+  compactU8: import_substrate_bindings._void,
+  compactU16: import_substrate_bindings._void,
+  compactU32: import_substrate_bindings._void,
+  compactU64: import_substrate_bindings._void,
+  compactU128: import_substrate_bindings._void,
+  compactU256: import_substrate_bindings._void,
+  void: import_substrate_bindings._void,
+  perId: import_substrate_bindings.compactNumber
+});
+var field = (0, import_substrate_bindings.Struct)({
+  name: (0, import_substrate_bindings.Option)(import_substrate_bindings.str),
+  ty: typeRef,
+  typeName: (0, import_substrate_bindings.Option)(import_substrate_bindings.str)
+});
+var typeDef = (0, import_substrate_bindings.ScaleEnum)({
+  composite: (0, import_substrate_bindings.Vector)(field),
+  enumeration: (0, import_substrate_bindings.Struct)({
+    name: import_substrate_bindings.str,
+    fields: (0, import_substrate_bindings.Vector)(field),
+    index: import_substrate_bindings.compactNumber
+  }),
+  sequence: typeRef,
+  array: (0, import_substrate_bindings.Struct)({
+    len: import_substrate_bindings.u32,
+    typeParam: typeRef
+  }),
+  tuple: (0, import_substrate_bindings.Vector)(typeRef),
+  bitSequence: (0, import_substrate_bindings.Struct)({
+    numBytes: import_substrate_bindings.u8,
+    leastSignificantBitFirst: import_substrate_bindings.bool
+  })
+});
+var lookupType = (0, import_substrate_bindings.Struct)({
+  path: (0, import_substrate_bindings.Vector)(import_substrate_bindings.str),
+  typeDef,
+  typeId: import_substrate_bindings.compactNumber
+});
+var lookup = (0, import_substrate_bindings.Vector)(lookupType);
+var extrinsicMetadata = (0, import_substrate_bindings.Struct)({
+  version: import_substrate_bindings.u8,
+  addressTy: typeRef,
+  callTy: typeRef,
+  signatureTy: typeRef,
+  signedExtensions: (0, import_substrate_bindings.Vector)(
+    (0, import_substrate_bindings.Struct)({
+      identifier: import_substrate_bindings.str,
+      includedInExtrinsic: typeRef,
+      includedInSignedData: typeRef
+    })
+  )
+});
+var versionDecoder = (0, import_substrate_bindings.enhanceDecoder)(import_substrate_bindings.u8[1], (value) => ({
+  version: value & ~(1 << 7),
+  signed: !!(value & 1 << 7)
+}));
+var extrinsicDec = import_substrate_bindings.Tuple.dec(
+  import_substrate_bindings.compact[1],
+  versionDecoder,
+  (0, import_substrate_bindings.Bytes)(Infinity)[1]
+);
+var proof = (0, import_substrate_bindings.Struct)({
+  leaves: lookup,
+  leafIdxs: (0, import_substrate_bindings.Vector)(import_substrate_bindings.u32),
+  proofs: (0, import_substrate_bindings.Vector)(hash),
+  extrinsic: extrinsicMetadata,
+  info: extraInfo
+});
+
+// src/get-accessible-types.ts
+var getAccessibleTypes = (metadata2, definitions) => {
+  const types = /* @__PURE__ */ new Set();
+  const collectTypesFromId = (id) => {
+    if (types.has(id)) return;
+    const { tag, value } = definitions.get(id).def;
+    switch (tag) {
+      case "composite":
+        if (!value.length) break;
+        types.add(id);
+        value.forEach(({ type }) => {
+          collectTypesFromId(type);
+        });
+        break;
+      case "variant":
+        if (!value.length) break;
+        types.add(id);
+        value.forEach(({ fields }) => {
+          fields.forEach(({ type }) => {
+            collectTypesFromId(type);
+          });
+        });
+        break;
+      case "tuple":
+        if (!value.length) break;
+        types.add(id);
+        value.forEach(collectTypesFromId);
+        break;
+      case "sequence":
+        types.add(id);
+        collectTypesFromId(value);
+        break;
+      case "array":
+        types.add(id);
+        collectTypesFromId(value.type);
+        break;
+      case "bitSequence":
+        types.add(id);
+    }
+  };
+  collectTypesFromId(metadata2.extrinsic.call);
+  collectTypesFromId(metadata2.extrinsic.address);
+  collectTypesFromId(metadata2.extrinsic.signature);
+  metadata2.extrinsic.signedExtensions.forEach(({ type, additionalSigned }) => {
+    collectTypesFromId(type);
+    collectTypesFromId(additionalSigned);
+  });
+  const sortedTypes = [...types].sort((a, b) => a - b);
+  return new Map(sortedTypes.map((value, idx) => [value, idx]));
+};
+
+// src/get-lookup.ts
+var bitSequenceBytes = {
+  u8: 1,
+  u16: 2,
+  u32: 4,
+  u64: 8
+};
+var constructTypeDef = (definitions, getTypeRef, getPrimitive, frameId) => {
+  const {
+    def: { tag, value }
+  } = definitions.get(frameId);
+  switch (tag) {
+    case "composite":
+      return [
+        {
+          tag,
+          value: value.map((f) => ({
+            name: f.name,
+            typeName: f.typeName,
+            ty: getTypeRef(f.type)
+          }))
+        }
+      ];
+    case "variant": {
+      return value.map((v) => ({
+        tag: "enumeration",
+        value: {
+          name: v.name,
+          index: v.index,
+          fields: v.fields.map((f) => ({
+            name: f.name,
+            typeName: f.typeName,
+            ty: getTypeRef(f.type)
+          }))
+        }
+      }));
+    }
+    case "sequence":
+      return [
+        {
+          tag,
+          value: getTypeRef(value)
+        }
+      ];
+    case "array":
+      return [
+        {
+          tag,
+          value: {
+            len: value.len,
+            typeParam: getTypeRef(value.type)
+          }
+        }
+      ];
+    case "tuple":
+      return [
+        {
+          tag,
+          value: value.map(getTypeRef)
+        }
+      ];
+    case "bitSequence": {
+      const primitive = getPrimitive(value.bitStoreType);
+      const numBytes = bitSequenceBytes[primitive];
+      if (!numBytes) throw new Error("Invalid primitive for BitSequence");
+      const storeOrderPath = definitions.get(value.bitOrderType).path;
+      const leastSignificantBitFirst = storeOrderPath.includes("Lsb0");
+      if (!leastSignificantBitFirst && !storeOrderPath.includes("Msb0"))
+        throw new Error("BitOrderType not recognized");
+      return [
+        {
+          tag: "bitSequence",
+          value: { numBytes, leastSignificantBitFirst }
+        }
+      ];
+    }
+  }
+  throw new Error(`FrameId(${frameId}) should have been filtered out`);
+};
+var getLookup = (definitions, accessibleTypes, getTypeRef, getPrimitive) => {
+  const typeTree = [];
+  [...accessibleTypes.entries()].forEach(([frameId, typeId]) => {
+    const { path } = definitions.get(frameId);
+    constructTypeDef(definitions, getTypeRef, getPrimitive, frameId).forEach(
+      (typeDef2) => {
+        typeTree.push({
+          path,
+          typeId,
+          typeDef: typeDef2
+        });
+      }
+    );
+  });
+  typeTree.sort((a, b) => {
+    if (a.typeId !== b.typeId) return a.typeId - b.typeId;
+    if (a.typeDef.tag !== "enumeration" || b.typeDef.tag !== "enumeration")
+      throw new Error("Found two types with same id");
+    return a.typeDef.value.index - b.typeDef.value.index;
+  });
+  return typeTree;
+};
+
+// src/get-metadata.ts
+var import_substrate_bindings2 = require("@polkadot-api/substrate-bindings");
+var opaqueBytes = (0, import_substrate_bindings2.Bytes)();
+var optionOpaque = (0, import_substrate_bindings2.Option)(opaqueBytes);
+var opaqueOpaqueBytes = (0, import_substrate_bindings2.Tuple)(import_substrate_bindings2.compact, opaqueBytes);
+var getAnyMetadata = (input) => {
+  try {
+    return import_substrate_bindings2.metadata.dec(input);
+  } catch (_) {
+  }
+  try {
+    return import_substrate_bindings2.metadata.dec(optionOpaque.dec(input));
+  } catch (_) {
+  }
+  try {
+    return import_substrate_bindings2.metadata.dec(opaqueBytes.dec(input));
+  } catch (_) {
+  }
+  try {
+    return import_substrate_bindings2.metadata.dec(opaqueOpaqueBytes.dec(input)[1]);
+  } catch (_) {
+  }
+  throw null;
+};
+var getMetadata = (input) => {
+  try {
+    const { metadata: metadata2 } = getAnyMetadata(input);
+    if (metadata2.tag !== "v15") throw new Error("Wrong metadata version");
+    return metadata2.value;
+  } catch (e) {
+    throw e || new Error("Unable to decode metadata");
+  }
+};
+
+// src/utils.ts
+var import_utils = require("@polkadot-api/utils");
+var mergeUint8 = (inputs) => {
+  const len = inputs.length;
+  let totalLen = 0;
+  for (let i = 0; i < len; i++) totalLen += inputs[i].byteLength;
+  const result = new Uint8Array(totalLen);
+  for (let idx = 0, at = 0; idx < len; idx++) {
+    const current = inputs[idx];
+    result.set(current, at);
+    at += current.byteLength;
+  }
+  return result;
+};
+var toBytes = (input) => typeof input === "string" ? (0, import_utils.fromHex)(input) : input;
+var compactTypeRefs = {
+  null: "void",
+  u8: "compactU8",
+  u16: "compactU16",
+  u32: "compactU32",
+  u64: "compactU64",
+  u128: "compactU128",
+  u256: "compactU256"
+};
+
+// src/decode-and-collect.ts
+var import_substrate_bindings3 = require("@polkadot-api/substrate-bindings");
+var typeRefDecoders = {
+  bool: import_substrate_bindings3.u8,
+  char: import_substrate_bindings3.u8,
+  str: import_substrate_bindings3.str,
+  u8: import_substrate_bindings3.u8,
+  u16: import_substrate_bindings3.u16,
+  u32: import_substrate_bindings3.u32,
+  u64: import_substrate_bindings3.u64,
+  u128: import_substrate_bindings3.u128,
+  u256: import_substrate_bindings3.u256,
+  i8: import_substrate_bindings3.i8,
+  i16: import_substrate_bindings3.i16,
+  i32: import_substrate_bindings3.i32,
+  i64: import_substrate_bindings3.i64,
+  i128: import_substrate_bindings3.i128,
+  i256: import_substrate_bindings3.i256,
+  void: import_substrate_bindings3._void,
+  compactU8: import_substrate_bindings3.compact,
+  compactU16: import_substrate_bindings3.compact,
+  compactU32: import_substrate_bindings3.compact,
+  compactU64: import_substrate_bindings3.compact,
+  compactU128: import_substrate_bindings3.compact,
+  compactU256: import_substrate_bindings3.compact
+};
+var innerDecodeAndCollect = (input, typeRef2, idToLookups, lookup2, collected) => {
+  if (typeRef2.tag !== "perId") {
+    typeRefDecoders[typeRef2.tag][1](input);
+    return;
+  }
+  const handleTypeRef = (typeRef3) => {
+    innerDecodeAndCollect(input, typeRef3, idToLookups, lookup2, collected);
+  };
+  const lookupIdxs = idToLookups.get(typeRef2.value);
+  const [currentIdx] = lookupIdxs;
+  const current = lookup2[currentIdx];
+  if (lookupIdxs.length === 1) collected.add(currentIdx);
+  switch (current.typeDef.tag) {
+    case "enumeration": {
+      const selectedIdx = import_substrate_bindings3.u8.dec(input);
+      const [selected, collectedIdx] = lookupIdxs.map(
+        (lookupIdx) => [lookup2[lookupIdx].typeDef, lookupIdx]
+      ).find(([x]) => x.value.index === selectedIdx);
+      collected.add(collectedIdx);
+      selected.value.fields.forEach(({ ty }) => {
+        handleTypeRef(ty);
+      });
+      break;
+    }
+    case "sequence": {
+      const len = import_substrate_bindings3.compact.dec(input);
+      for (let i = 0; i < len; i++) handleTypeRef(current.typeDef.value);
+      break;
+    }
+    case "array": {
+      for (let i = 0; i < current.typeDef.value.len; i++)
+        handleTypeRef(current.typeDef.value.typeParam);
+      break;
+    }
+    case "composite": {
+      current.typeDef.value.forEach((x) => {
+        handleTypeRef(x.ty);
+      });
+      break;
+    }
+    case "tuple": {
+      current.typeDef.value.forEach(handleTypeRef);
+      break;
+    }
+    case "bitSequence":
+      throw new Error("bitSequence is not supported");
+  }
+};
+var decodeAndCollectKnownLeafs = (data, typeRefs, lookup2) => {
+  let input = new Uint8Array();
+  (0, import_substrate_bindings3.createDecoder)((_input) => {
+    input = _input;
+  })(data);
+  const idToLookups = /* @__PURE__ */ new Map();
+  lookup2.forEach((lookup3, idx) => {
+    const arr = idToLookups.get(lookup3.typeId);
+    if (arr) arr.push(idx);
+    else idToLookups.set(lookup3.typeId, [idx]);
+  });
+  const result = /* @__PURE__ */ new Set();
+  typeRefs.forEach((typeRef2) => {
+    innerDecodeAndCollect(input, typeRef2, idToLookups, lookup2, result);
+  });
+  return [...result].sort((a, b) => a - b);
+};
+
+// src/proof.ts
+var getLevelFromIdx = (idx) => Math.log2(idx + 1) | 0;
+var getAncestorIdx = (from, nLevels) => (from + 1 >> nLevels) - 1;
+function getProofData(leaves, knownLeavesIdxs) {
+  const knownLeaves = knownLeavesIdxs.map((idx) => leaves[idx]);
+  const startingIdx = leaves.length - 1;
+  const leafIdxs = knownLeavesIdxs.map((idx) => startingIdx + idx);
+  const proofIdxs = [];
+  if (leafIdxs.length) {
+    const nLevels = getLevelFromIdx(leafIdxs.at(-1));
+    const splitPosition = Math.pow(2, nLevels) - 1;
+    const splitIdx = leafIdxs.findIndex((x) => x >= splitPosition);
+    if (splitIdx > 0) {
+      leafIdxs.unshift(...leafIdxs.splice(splitIdx));
+      knownLeaves.unshift(...knownLeaves.splice(splitIdx));
+    }
+  }
+  let targetIdx = 0;
+  const traverse = (nodeIdx) => {
+    if (targetIdx === leafIdxs.length) {
+      proofIdxs.push(nodeIdx);
+      return;
+    }
+    const target = leafIdxs[targetIdx];
+    if (target === nodeIdx) {
+      ++targetIdx;
+      return;
+    }
+    const currentLevel = getLevelFromIdx(nodeIdx);
+    const targetLevel = getLevelFromIdx(target);
+    if (nodeIdx !== getAncestorIdx(target, targetLevel - currentLevel)) {
+      proofIdxs.push(nodeIdx);
+      return;
+    }
+    const leftSon = 2 * nodeIdx + 1;
+    traverse(leftSon);
+    traverse(leftSon + 1);
+  };
+  traverse(0);
+  return {
+    leaves: knownLeaves,
+    leafIdxs,
+    proofIdxs
+  };
+}
+
+// src/main.ts
+var merkleizeMetadata = (metadataBytes, info) => {
+  const metadata2 = getMetadata(metadataBytes);
+  const definitions = new Map(
+    metadata2.lookup.map((value) => [value.id, value])
+  );
+  const accessibleTypes = getAccessibleTypes(metadata2, definitions);
+  const getPrimitive = (frameId) => {
+    const {
+      def: { tag, value }
+    } = definitions.get(frameId);
+    if (tag === "primitive") return value.tag;
+    if (tag !== "composite" && tag !== "tuple" || value.length > 1)
+      throw new Error("The provided definition doesn't map to a primitive");
+    return value.length === 0 ? null : getPrimitive(tag === "tuple" ? value[0] : value[0].type);
+  };
+  const getTypeRef = (frameId) => {
+    const { def } = definitions.get(frameId);
+    if (def.tag === "primitive") return { tag: def.value.tag, value: void 0 };
+    if (def.tag === "compact") {
+      const primitive = getPrimitive(def.value);
+      const tag = compactTypeRefs[primitive];
+      if (!tag) throw new Error("Invalid primitive for Compact");
+      return { tag, value: void 0 };
+    }
+    return accessibleTypes.has(frameId) ? { tag: "perId", value: accessibleTypes.get(frameId) } : { tag: "void", value: void 0 };
+  };
+  const extrinsic = {
+    version: metadata2.extrinsic.version,
+    addressTy: getTypeRef(metadata2.extrinsic.address),
+    callTy: getTypeRef(metadata2.extrinsic.call),
+    signatureTy: getTypeRef(metadata2.extrinsic.signature),
+    signedExtensions: metadata2.extrinsic.signedExtensions.map((se) => ({
+      identifier: se.identifier,
+      includedInExtrinsic: getTypeRef(se.type),
+      includedInSignedData: getTypeRef(se.additionalSigned)
+    }))
+  };
+  const lookup2 = getLookup(
+    definitions,
+    accessibleTypes,
+    getTypeRef,
+    getPrimitive
+  );
+  const lookupEncoded = lookup2.map(lookupType.enc);
+  let hashTree;
+  const getHashTree = () => {
+    if (hashTree) return hashTree;
+    if (!lookupEncoded.length) return hashTree = [new Uint8Array(32).fill(0)];
+    hashTree = new Array(lookupEncoded.length * 2 - 1);
+    let leavesStartIdx = lookupEncoded.length - 1;
+    for (let i = 0; i < lookupEncoded.length; i++)
+      hashTree[leavesStartIdx + i] = (0, import_substrate_bindings4.Blake3256)(lookupEncoded[i]);
+    for (let i = hashTree.length - 2; i > 0; i -= 2)
+      hashTree[(i - 1) / 2] = (0, import_substrate_bindings4.Blake3256)(
+        mergeUint8([hashTree[i], hashTree[i + 1]])
+      );
+    return hashTree;
+  };
+  let digested;
+  const digest = () => {
+    if (digested) return digested;
+    const rootLookupHash = getHashTree()[0];
+    const digest2 = {
+      tag: "V1",
+      value: {
+        typeInformationTreeRoot: rootLookupHash,
+        extrinsicMetadataHash: (0, import_substrate_bindings4.Blake3256)(extrinsicMetadata.enc(extrinsic)),
+        ...info
+      }
+    };
+    return digested = (0, import_substrate_bindings4.Blake3256)(metadataDigest.enc(digest2));
+  };
+  const generateProof = (knownIndexes) => {
+    const proofData = getProofData(lookupEncoded, knownIndexes);
+    const hashTree2 = getHashTree();
+    const proofs = proofData.proofIdxs.map((idx) => hashTree2[idx]);
+    return mergeUint8([
+      import_substrate_bindings4.compact.enc(proofData.leaves.length),
+      ...proofData.leaves,
+      import_substrate_bindings4.compact.enc(proofData.leafIdxs.length),
+      ...proofData.leafIdxs.map((x) => import_substrate_bindings4.u32.enc(x)),
+      import_substrate_bindings4.compact.enc(proofs.length),
+      ...proofs,
+      extrinsicMetadata.enc(extrinsic),
+      extraInfo.enc(info)
+    ]);
+  };
+  const getProofForExtrinsicParts = (callData, includedInExtrinsic, includedInSignedData) => {
+    const bytes = mergeUint8(
+      [callData, includedInExtrinsic, includedInSignedData].map(toBytes)
+    );
+    const typeRefs = [
+      extrinsic.callTy,
+      ...extrinsic.signedExtensions.map((x) => x.includedInExtrinsic),
+      ...extrinsic.signedExtensions.map((x) => x.includedInSignedData)
+    ];
+    return generateProof(decodeAndCollectKnownLeafs(bytes, typeRefs, lookup2));
+  };
+  const getProofForExtrinsic = (transaction, txAdditionalSigned) => {
+    let [, { version, signed }, bytes] = extrinsicDec(transaction);
+    if (version !== extrinsic.version)
+      throw new Error("Incorrect extrinsic version");
+    const typeRefs = signed ? [
+      extrinsic.addressTy,
+      extrinsic.signatureTy,
+      ...extrinsic.signedExtensions.map((x) => x.includedInExtrinsic),
+      extrinsic.callTy
+    ] : [extrinsic.callTy];
+    if (txAdditionalSigned) {
+      bytes = mergeUint8([bytes, toBytes(txAdditionalSigned)]);
+      typeRefs.push(
+        ...extrinsic.signedExtensions.map((x) => x.includedInSignedData)
+      );
+    }
+    return generateProof(decodeAndCollectKnownLeafs(bytes, typeRefs, lookup2));
+  };
+  return {
+    digest,
+    getProofForExtrinsic,
+    getProofForExtrinsicParts
+  };
+};
+//# sourceMappingURL=index.js.map