@polkadot-api/merkleize-metadata 1.1.0 → 1.1.1

package/dist/esm/codecs.mjs

@@ -0,0 +1,122 @@
+import { Struct, Bytes, ScaleEnum, _void, compactNumber, Option, str, Vector, u32, u8, bool, enhanceDecoder, Tuple, compact, u16 } from '@polkadot-api/substrate-bindings';
+
+const extraInfoInner = {
+  specVersion: u32,
+  specName: str,
+  base58Prefix: u16,
+  decimals: u8,
+  tokenSymbol: str
+};
+const extraInfo = Struct(extraInfoInner);
+const hash = Bytes(32);
+const metadataDigest = ScaleEnum({
+  V0: _void,
+  V1: Struct({
+    typeInformationTreeRoot: hash,
+    extrinsicMetadataHash: hash,
+    ...extraInfoInner
+  })
+});
+ScaleEnum({
+  bool: _void,
+  char: _void,
+  str: _void,
+  u8: _void,
+  u16: _void,
+  u32: _void,
+  u64: _void,
+  u128: _void,
+  u256: _void,
+  i8: _void,
+  i16: _void,
+  i32: _void,
+  i64: _void,
+  i128: _void,
+  i256: _void
+});
+const typeRef = ScaleEnum({
+  bool: _void,
+  char: _void,
+  str: _void,
+  u8: _void,
+  u16: _void,
+  u32: _void,
+  u64: _void,
+  u128: _void,
+  u256: _void,
+  i8: _void,
+  i16: _void,
+  i32: _void,
+  i64: _void,
+  i128: _void,
+  i256: _void,
+  compactU8: _void,
+  compactU16: _void,
+  compactU32: _void,
+  compactU64: _void,
+  compactU128: _void,
+  compactU256: _void,
+  void: _void,
+  perId: compactNumber
+});
+const field = Struct({
+  name: Option(str),
+  ty: typeRef,
+  typeName: Option(str)
+});
+const typeDef = ScaleEnum({
+  composite: Vector(field),
+  enumeration: Struct({
+    name: str,
+    fields: Vector(field),
+    index: compactNumber
+  }),
+  sequence: typeRef,
+  array: Struct({
+    len: u32,
+    typeParam: typeRef
+  }),
+  tuple: Vector(typeRef),
+  bitSequence: Struct({
+    numBytes: u8,
+    leastSignificantBitFirst: bool
+  })
+});
+const lookupType = Struct({
+  path: Vector(str),
+  typeDef,
+  typeId: compactNumber
+});
+const lookup = Vector(lookupType);
+const extrinsicMetadata = Struct({
+  version: u8,
+  addressTy: typeRef,
+  callTy: typeRef,
+  signatureTy: typeRef,
+  signedExtensions: Vector(
+    Struct({
+      identifier: str,
+      includedInExtrinsic: typeRef,
+      includedInSignedData: typeRef
+    })
+  )
+});
+const versionDecoder = enhanceDecoder(u8[1], (value) => ({
+  version: value & ~(1 << 7),
+  signed: !!(value & 1 << 7)
+}));
+const extrinsicDec = Tuple.dec(
+  compact[1],
+  versionDecoder,
+  Bytes(Infinity)[1]
+);
+const proof = Struct({
+  leaves: lookup,
+  leafIdxs: Vector(u32),
+  proofs: Vector(hash),
+  extrinsic: extrinsicMetadata,
+  info: extraInfo
+});
+
+export { extraInfo, extrinsicDec, extrinsicMetadata, hash, lookup, lookupType, metadataDigest, proof, typeDef, typeRef };
+//# sourceMappingURL=codecs.mjs.map

package/dist/esm/codecs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codecs.mjs","sources":["../../src/codecs.ts"],"sourcesContent":["import {\n  Bytes,\n  Codec,\n  CodecType,\n  Option,\n  ScaleEnum,\n  Struct,\n  Tuple,\n  V15,\n  Vector,\n  _void,\n  bool,\n  compact,\n  compactNumber,\n  enhanceDecoder,\n  str,\n  u16,\n  u32,\n  u8,\n} from \"@polkadot-api/substrate-bindings\"\n\nconst extraInfoInner = {\n  specVersion: u32,\n  specName: str,\n  base58Prefix: u16,\n  decimals: u8,\n  tokenSymbol: str,\n}\nexport const extraInfo = Struct(extraInfoInner)\nexport type ExtraInfo = CodecType<typeof extraInfo>\n\nexport const hash = Bytes(32)\nexport const metadataDigest = ScaleEnum({\n  V0: _void,\n  V1: Struct({\n    typeInformationTreeRoot: hash,\n    extrinsicMetadataHash: hash,\n    ...extraInfoInner,\n  }),\n})\nexport type MetadataDigest = CodecType<typeof metadataDigest>\n\nexport const scalePrimitive = ScaleEnum({\n  bool: _void,\n  char: _void,\n  str: _void,\n  u8: _void,\n  u16: _void,\n  u32: _void,\n  u64: _void,\n  u128: _void,\n  u256: _void,\n  i8: _void,\n  i16: _void,\n  i32: _void,\n  i64: _void,\n  i128: _void,\n  i256: _void,\n})\nexport type ScalePrimitive = CodecType<typeof scalePrimitive>\n\nexport const typeRef = ScaleEnum({\n  bool: _void,\n  char: _void,\n  str: _void,\n  u8: _void,\n  u16: _void,\n  u32: _void,\n  u64: _void,\n  u128: _void,\n  u256: _void,\n  i8: _void,\n  i16: _void,\n  i32: _void,\n  i64: _void,\n  i128: _void,\n  i256: _void,\n  compactU8: _void,\n  compactU16: _void,\n  compactU32: _void,\n  compactU64: _void,\n  compactU128: _void,\n  compactU256: _void,\n  void: _void,\n  perId: compactNumber,\n})\nexport type TypeRef = CodecType<typeof typeRef>\n\nconst field = Struct({\n  name: Option(str),\n  ty: typeRef,\n  typeName: Option(str),\n})\nexport const typeDef = ScaleEnum({\n  composite: Vector(field),\n  enumeration: Struct({\n    name: str,\n    fields: Vector(field),\n    index: compactNumber,\n  }),\n  sequence: typeRef,\n  array: Struct({\n    len: u32,\n    typeParam: typeRef,\n  }),\n  tuple: Vector(typeRef),\n  bitSequence: Struct({\n    numBytes: u8,\n    leastSignificantBitFirst: bool,\n  }),\n})\nexport type TypeDef = CodecType<typeof typeDef>\n\nexport const lookupType = Struct({\n  path: Vector(str),\n  typeDef: typeDef,\n  typeId: compactNumber,\n})\nexport type LookupEntry = CodecType<typeof lookupType>\nexport type Lookup = Array<LookupEntry>\nexport const lookup: Codec<Lookup> = Vector(lookupType)\n\nexport const extrinsicMetadata = Struct({\n  version: u8,\n  addressTy: typeRef,\n  callTy: typeRef,\n  signatureTy: typeRef,\n  signedExtensions: Vector(\n    Struct({\n      identifier: str,\n      includedInExtrinsic: typeRef,\n      includedInSignedData: typeRef,\n    }),\n  ),\n})\nexport type ExtrinsicMetadata = CodecType<typeof extrinsicMetadata>\nexport type LookupValue = V15[\"lookup\"] extends Array<infer T> ? T : never\n\nconst versionDecoder = enhanceDecoder(u8[1], (value) => ({\n  version: value & ~(1 << 7),\n  signed: !!(value & (1 << 7)),\n}))\n\nexport const extrinsicDec = Tuple.dec(\n  compact[1],\n  versionDecoder,\n  Bytes(Infinity)[1],\n)\n\nexport const proof = Struct({\n  leaves: lookup,\n  leafIdxs: Vector(u32),\n  proofs: Vector(hash),\n  extrinsic: extrinsicMetadata,\n  info: extraInfo,\n})\nexport type Proof = CodecType<typeof proof>\n"],"names":[],"mappings":"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"}

package/dist/esm/decode-and-collect.mjs

@@ -0,0 +1,94 @@
+import { createDecoder, compact, u8, str, u16, u32, u64, u128, u256, i8, i16, i32, i64, i128, i256, _void } from '@polkadot-api/substrate-bindings';
+
+const typeRefDecoders = {
+  bool: u8,
+  char: u8,
+  str,
+  u8,
+  u16,
+  u32,
+  u64,
+  u128,
+  u256,
+  i8,
+  i16,
+  i32,
+  i64,
+  i128,
+  i256,
+  void: _void,
+  compactU8: compact,
+  compactU16: compact,
+  compactU32: compact,
+  compactU64: compact,
+  compactU128: compact,
+  compactU256: compact
+};
+const innerDecodeAndCollect = (input, typeRef, idToLookups, lookup, collected) => {
+  if (typeRef.tag !== "perId") {
+    typeRefDecoders[typeRef.tag][1](input);
+    return;
+  }
+  const handleTypeRef = (typeRef2) => {
+    innerDecodeAndCollect(input, typeRef2, idToLookups, lookup, collected);
+  };
+  const lookupIdxs = idToLookups.get(typeRef.value);
+  const [currentIdx] = lookupIdxs;
+  const current = lookup[currentIdx];
+  if (lookupIdxs.length === 1) collected.add(currentIdx);
+  switch (current.typeDef.tag) {
+    case "enumeration": {
+      const selectedIdx = u8.dec(input);
+      const [selected, collectedIdx] = lookupIdxs.map(
+        (lookupIdx) => [lookup[lookupIdx].typeDef, lookupIdx]
+      ).find(([x]) => x.value.index === selectedIdx);
+      collected.add(collectedIdx);
+      selected.value.fields.forEach(({ ty }) => {
+        handleTypeRef(ty);
+      });
+      break;
+    }
+    case "sequence": {
+      const len = 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");
+  }
+};
+const decodeAndCollectKnownLeafs = (data, typeRefs, lookup) => {
+  let input = new Uint8Array();
+  createDecoder((_input) => {
+    input = _input;
+  })(data);
+  const idToLookups = /* @__PURE__ */ new Map();
+  lookup.forEach((lookup2, idx) => {
+    const arr = idToLookups.get(lookup2.typeId);
+    if (arr) arr.push(idx);
+    else idToLookups.set(lookup2.typeId, [idx]);
+  });
+  const result = /* @__PURE__ */ new Set();
+  typeRefs.forEach((typeRef) => {
+    innerDecodeAndCollect(input, typeRef, idToLookups, lookup, result);
+  });
+  return [...result].sort((a, b) => a - b);
+};
+
+export { decodeAndCollectKnownLeafs };
+//# sourceMappingURL=decode-and-collect.mjs.map

package/dist/esm/decode-and-collect.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode-and-collect.mjs","sources":["../../src/decode-and-collect.ts"],"sourcesContent":["import {\n  HexString,\n  _void,\n  compact,\n  createDecoder,\n  i128,\n  i16,\n  i256,\n  i32,\n  i64,\n  i8,\n  str,\n  u128,\n  u16,\n  u256,\n  u32,\n  u64,\n  u8,\n} from \"@polkadot-api/substrate-bindings\"\nimport { Lookup, TypeDef, TypeRef } from \"./codecs\"\n\nconst typeRefDecoders = {\n  bool: u8,\n  char: u8,\n  str,\n  u8,\n  u16,\n  u32,\n  u64,\n  u128,\n  u256,\n  i8,\n  i16,\n  i32,\n  i64,\n  i128,\n  i256,\n  void: _void,\n  compactU8: compact,\n  compactU16: compact,\n  compactU32: compact,\n  compactU64: compact,\n  compactU128: compact,\n  compactU256: compact,\n}\n\nconst innerDecodeAndCollect = (\n  input: Uint8Array,\n  typeRef: TypeRef,\n  idToLookups: Map<number, Array<number>>,\n  lookup: Lookup,\n  collected: Set<number>,\n) => {\n  if (typeRef.tag !== \"perId\") {\n    typeRefDecoders[typeRef.tag][1](input)\n    return\n  }\n\n  const handleTypeRef = (typeRef: TypeRef) => {\n    innerDecodeAndCollect(input, typeRef, idToLookups, lookup, collected)\n  }\n\n  const lookupIdxs = idToLookups.get(typeRef.value)!\n  const [currentIdx] = lookupIdxs\n  const current = lookup[currentIdx]\n\n  if (lookupIdxs.length === 1) collected.add(currentIdx)\n\n  switch (current.typeDef.tag) {\n    case \"enumeration\": {\n      const selectedIdx = u8.dec(input)\n      const [selected, collectedIdx] = lookupIdxs\n        .map(\n          (lookupIdx) =>\n            [lookup[lookupIdx].typeDef, lookupIdx] as [\n              TypeDef & { tag: \"enumeration\" },\n              number,\n            ],\n        )\n        .find(([x]) => x.value.index === selectedIdx)!\n      collected.add(collectedIdx)\n      selected.value.fields.forEach(({ ty }) => {\n        handleTypeRef(ty)\n      })\n      break\n    }\n    case \"sequence\": {\n      const len = compact.dec(input)\n      for (let i = 0; i < len; i++) handleTypeRef(current.typeDef.value)\n      break\n    }\n    case \"array\": {\n      for (let i = 0; i < current.typeDef.value.len; i++)\n        handleTypeRef(current.typeDef.value.typeParam)\n      break\n    }\n    case \"composite\": {\n      current.typeDef.value.forEach((x) => {\n        handleTypeRef(x.ty)\n      })\n      break\n    }\n    case \"tuple\": {\n      current.typeDef.value.forEach(handleTypeRef)\n      break\n    }\n    case \"bitSequence\":\n      throw new Error(\"bitSequence is not supported\")\n  }\n}\n\nexport const decodeAndCollectKnownLeafs = (\n  data: Uint8Array | HexString,\n  typeRefs: Array<TypeRef>,\n  lookup: Lookup,\n): Array<number> => {\n  let input = new Uint8Array()\n  createDecoder((_input) => {\n    input = _input\n  })(data)\n\n  const idToLookups = new Map<number, number[]>()\n  lookup.forEach((lookup, idx) => {\n    const arr = idToLookups.get(lookup.typeId)\n    if (arr) arr.push(idx)\n    else idToLookups.set(lookup.typeId, [idx])\n  })\n\n  const result = new Set<number>()\n  typeRefs.forEach((typeRef) => {\n    innerDecodeAndCollect(input, typeRef, idToLookups, lookup, result)\n  })\n\n  return [...result].sort((a, b) => a - b)\n}\n"],"names":["typeRef","lookup"],"mappings":"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"}

package/dist/esm/get-accessible-types.mjs

@@ -0,0 +1,52 @@
+const getAccessibleTypes = (metadata, 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(metadata.extrinsic.call);
+  collectTypesFromId(metadata.extrinsic.address);
+  collectTypesFromId(metadata.extrinsic.signature);
+  metadata.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]));
+};
+
+export { getAccessibleTypes };
+//# sourceMappingURL=get-accessible-types.mjs.map

package/dist/esm/get-accessible-types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-accessible-types.mjs","sources":["../../src/get-accessible-types.ts"],"sourcesContent":["import { V15 } from \"@polkadot-api/substrate-bindings\"\nimport { LookupValue } from \"./codecs\"\n\nexport const getAccessibleTypes = (\n  metadata: V15,\n  definitions: Map<number, LookupValue>,\n): Map<number, number> => {\n  const types = new Set<number>()\n\n  const collectTypesFromId = (id: number) => {\n    if (types.has(id)) return\n\n    const { tag, value } = definitions.get(id)!.def\n    switch (tag) {\n      case \"composite\":\n        if (!value.length) break\n        types.add(id)\n        value.forEach(({ type }) => {\n          collectTypesFromId(type)\n        })\n        break\n      case \"variant\":\n        if (!value.length) break\n        types.add(id)\n        value.forEach(({ fields }) => {\n          fields.forEach(({ type }) => {\n            collectTypesFromId(type)\n          })\n        })\n        break\n      case \"tuple\":\n        if (!value.length) break\n        types.add(id)\n        value.forEach(collectTypesFromId)\n        break\n      case \"sequence\":\n        types.add(id)\n        collectTypesFromId(value)\n        break\n      case \"array\":\n        types.add(id)\n        collectTypesFromId(value.type)\n        break\n      case \"bitSequence\": // bitSequence inner types are not stored\n        types.add(id)\n      // primitive and compact are not stored\n    }\n  }\n\n  collectTypesFromId(metadata.extrinsic.call)\n  collectTypesFromId(metadata.extrinsic.address)\n  collectTypesFromId(metadata.extrinsic.signature)\n  metadata.extrinsic.signedExtensions.forEach(({ type, additionalSigned }) => {\n    collectTypesFromId(type)\n    collectTypesFromId(additionalSigned)\n  })\n\n  const sortedTypes = [...types].sort((a, b) => a - b)\n  return new Map(sortedTypes.map((value, idx) => [value, idx]))\n}\n"],"names":[],"mappings":"AAGa,MAAA,kBAAA,GAAqB,CAChC,QAAA,EACA,WACwB,KAAA;AACxB,EAAM,MAAA,KAAA,uBAAY,GAAY,EAAA,CAAA;AAE9B,EAAM,MAAA,kBAAA,GAAqB,CAAC,EAAe,KAAA;AACzC,IAAI,IAAA,KAAA,CAAM,GAAI,CAAA,EAAE,CAAG,EAAA,OAAA;AAEnB,IAAA,MAAM,EAAE,GAAK,EAAA,KAAA,KAAU,WAAY,CAAA,GAAA,CAAI,EAAE,CAAG,CAAA,GAAA,CAAA;AAC5C,IAAA,QAAQ,GAAK;AAAA,MACX,KAAK,WAAA;AACH,QAAI,IAAA,CAAC,MAAM,MAAQ,EAAA,MAAA;AACnB,QAAA,KAAA,CAAM,IAAI,EAAE,CAAA,CAAA;AACZ,QAAA,KAAA,CAAM,OAAQ,CAAA,CAAC,EAAE,IAAA,EAAW,KAAA;AAC1B,UAAA,kBAAA,CAAmB,IAAI,CAAA,CAAA;AAAA,SACxB,CAAA,CAAA;AACD,QAAA,MAAA;AAAA,MACF,KAAK,SAAA;AACH,QAAI,IAAA,CAAC,MAAM,MAAQ,EAAA,MAAA;AACnB,QAAA,KAAA,CAAM,IAAI,EAAE,CAAA,CAAA;AACZ,QAAA,KAAA,CAAM,OAAQ,CAAA,CAAC,EAAE,MAAA,EAAa,KAAA;AAC5B,UAAA,MAAA,CAAO,OAAQ,CAAA,CAAC,EAAE,IAAA,EAAW,KAAA;AAC3B,YAAA,kBAAA,CAAmB,IAAI,CAAA,CAAA;AAAA,WACxB,CAAA,CAAA;AAAA,SACF,CAAA,CAAA;AACD,QAAA,MAAA;AAAA,MACF,KAAK,OAAA;AACH,QAAI,IAAA,CAAC,MAAM,MAAQ,EAAA,MAAA;AACnB,QAAA,KAAA,CAAM,IAAI,EAAE,CAAA,CAAA;AACZ,QAAA,KAAA,CAAM,QAAQ,kBAAkB,CAAA,CAAA;AAChC,QAAA,MAAA;AAAA,MACF,KAAK,UAAA;AACH,QAAA,KAAA,CAAM,IAAI,EAAE,CAAA,CAAA;AACZ,QAAA,kBAAA,CAAmB,KAAK,CAAA,CAAA;AACxB,QAAA,MAAA;AAAA,MACF,KAAK,OAAA;AACH,QAAA,KAAA,CAAM,IAAI,EAAE,CAAA,CAAA;AACZ,QAAA,kBAAA,CAAmB,MAAM,IAAI,CAAA,CAAA;AAC7B,QAAA,MAAA;AAAA,MACF,KAAK,aAAA;AACH,QAAA,KAAA,CAAM,IAAI,EAAE,CAAA,CAAA;AAAA,KAEhB;AAAA,GACF,CAAA;AAEA,EAAmB,kBAAA,CAAA,QAAA,CAAS,UAAU,IAAI,CAAA,CAAA;AAC1C,EAAmB,kBAAA,CAAA,QAAA,CAAS,UAAU,OAAO,CAAA,CAAA;AAC7C,EAAmB,kBAAA,CAAA,QAAA,CAAS,UAAU,SAAS,CAAA,CAAA;AAC/C,EAAA,QAAA,CAAS,UAAU,gBAAiB,CAAA,OAAA,CAAQ,CAAC,EAAE,IAAA,EAAM,kBAAuB,KAAA;AAC1E,IAAA,kBAAA,CAAmB,IAAI,CAAA,CAAA;AACvB,IAAA,kBAAA,CAAmB,gBAAgB,CAAA,CAAA;AAAA,GACpC,CAAA,CAAA;AAED,EAAM,MAAA,WAAA,GAAc,CAAC,GAAG,KAAK,CAAA,CAAE,KAAK,CAAC,CAAA,EAAG,CAAM,KAAA,CAAA,GAAI,CAAC,CAAA,CAAA;AACnD,EAAO,OAAA,IAAI,GAAI,CAAA,WAAA,CAAY,GAAI,CAAA,CAAC,KAAO,EAAA,GAAA,KAAQ,CAAC,KAAA,EAAO,GAAG,CAAC,CAAC,CAAA,CAAA;AAC9D;;;;"}

package/dist/esm/get-lookup.mjs

@@ -0,0 +1,103 @@
+const bitSequenceBytes = {
+  u8: 1,
+  u16: 2,
+  u32: 4,
+  u64: 8
+};
+const 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`);
+};
+const getLookup = (definitions, accessibleTypes, getTypeRef, getPrimitive) => {
+  const typeTree = [];
+  [...accessibleTypes.entries()].forEach(([frameId, typeId]) => {
+    const { path } = definitions.get(frameId);
+    constructTypeDef(definitions, getTypeRef, getPrimitive, frameId).forEach(
+      (typeDef) => {
+        typeTree.push({
+          path,
+          typeId,
+          typeDef
+        });
+      }
+    );
+  });
+  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;
+};
+
+export { getLookup };
+//# sourceMappingURL=get-lookup.mjs.map

package/dist/esm/get-lookup.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-lookup.mjs","sources":["../../src/get-lookup.ts"],"sourcesContent":["import { Lookup, LookupValue, ScalePrimitive, TypeDef, TypeRef } from \"./codecs\"\n\nconst bitSequenceBytes = {\n  u8: 1,\n  u16: 2,\n  u32: 4,\n  u64: 8,\n}\n\nconst constructTypeDef = (\n  definitions: Map<number, LookupValue>,\n  getTypeRef: (frameId: number) => TypeRef,\n  getPrimitive: (frameId: number) => ScalePrimitive[\"tag\"] | null,\n  frameId: number,\n): TypeDef[] => {\n  const {\n    def: { tag, value },\n  } = definitions.get(frameId)!\n  switch (tag) {\n    case \"composite\":\n      return [\n        {\n          tag,\n          value: value.map((f) => ({\n            name: f.name,\n            typeName: f.typeName,\n            ty: getTypeRef(f.type),\n          })),\n        },\n      ]\n    case \"variant\": {\n      return value.map((v) => ({\n        tag: \"enumeration\",\n        value: {\n          name: v.name,\n          index: v.index,\n          fields: v.fields.map((f) => ({\n            name: f.name,\n            typeName: f.typeName,\n            ty: getTypeRef(f.type),\n          })),\n        },\n      }))\n    }\n    case \"sequence\":\n      return [\n        {\n          tag,\n          value: getTypeRef(value),\n        },\n      ]\n    case \"array\":\n      return [\n        {\n          tag,\n          value: {\n            len: value.len,\n            typeParam: getTypeRef(value.type),\n          },\n        },\n      ]\n    case \"tuple\":\n      return [\n        {\n          tag,\n          value: value.map(getTypeRef),\n        },\n      ]\n    case \"bitSequence\": {\n      const primitive = getPrimitive(value.bitStoreType)\n      const numBytes = bitSequenceBytes[primitive as \"u8\"]\n      if (!numBytes) throw new Error(\"Invalid primitive for BitSequence\")\n\n      const storeOrderPath = definitions.get(value.bitOrderType)!.path\n      const leastSignificantBitFirst = storeOrderPath.includes(\"Lsb0\")\n      if (!leastSignificantBitFirst && !storeOrderPath.includes(\"Msb0\"))\n        throw new Error(\"BitOrderType not recognized\")\n\n      return [\n        {\n          tag: \"bitSequence\",\n          value: { numBytes, leastSignificantBitFirst },\n        },\n      ]\n    }\n  }\n\n  throw new Error(`FrameId(${frameId}) should have been filtered out`)\n}\n\nexport const getLookup = (\n  definitions: Map<number, LookupValue>,\n  accessibleTypes: Map<number, number>,\n  getTypeRef: (frameId: number) => TypeRef,\n  getPrimitive: (frameId: number) => ScalePrimitive[\"tag\"] | null,\n) => {\n  const typeTree: Lookup = []\n  ;[...accessibleTypes.entries()].forEach(([frameId, typeId]) => {\n    const { path } = definitions.get(frameId)!\n    constructTypeDef(definitions, getTypeRef, getPrimitive, frameId).forEach(\n      (typeDef) => {\n        typeTree.push({\n          path,\n          typeId,\n          typeDef,\n        })\n      },\n    )\n  })\n\n  typeTree.sort((a, b) => {\n    if (a.typeId !== b.typeId) return a.typeId - b.typeId // in general\n    // should only happen for variants\n    if (a.typeDef.tag !== \"enumeration\" || b.typeDef.tag !== \"enumeration\")\n      throw new Error(\"Found two types with same id\")\n    return a.typeDef.value.index - b.typeDef.value.index\n  })\n  return typeTree\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/get-metadata.mjs

@@ -0,0 +1,36 @@
+import { Bytes, Option, Tuple, compact, metadata } from '@polkadot-api/substrate-bindings';
+
+const opaqueBytes = Bytes();
+const optionOpaque = Option(opaqueBytes);
+const opaqueOpaqueBytes = Tuple(compact, opaqueBytes);
+const getAnyMetadata = (input) => {
+  try {
+    return metadata.dec(input);
+  } catch (_) {
+  }
+  try {
+    return metadata.dec(optionOpaque.dec(input));
+  } catch (_) {
+  }
+  try {
+    return metadata.dec(opaqueBytes.dec(input));
+  } catch (_) {
+  }
+  try {
+    return metadata.dec(opaqueOpaqueBytes.dec(input)[1]);
+  } catch (_) {
+  }
+  throw null;
+};
+const 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");
+  }
+};
+
+export { getMetadata };
+//# sourceMappingURL=get-metadata.mjs.map

package/dist/esm/get-metadata.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-metadata.mjs","sources":["../../src/get-metadata.ts"],"sourcesContent":["import {\n  Option,\n  Bytes,\n  metadata,\n  compact,\n  Tuple,\n  V15,\n} from \"@polkadot-api/substrate-bindings\"\nimport { HexString } from \"@polkadot-api/substrate-bindings\"\n\nconst opaqueBytes = Bytes()\nconst optionOpaque = Option(opaqueBytes)\nconst opaqueOpaqueBytes = Tuple(compact, opaqueBytes)\n\nconst getAnyMetadata = (input: Uint8Array | HexString) => {\n  try {\n    return metadata.dec(input)\n  } catch (_) {}\n\n  // comes from metadata.metadata_at_version\n  try {\n    return metadata.dec(optionOpaque.dec(input)!)\n  } catch (_) {}\n\n  // comes from state.getMetadata\n  try {\n    return metadata.dec(opaqueBytes.dec(input))\n  } catch (_) {}\n\n  // comes from metadata.metadata\n  try {\n    return metadata.dec(opaqueOpaqueBytes.dec(input)[1])\n  } catch (_) {}\n\n  throw null\n}\n\nexport const getMetadata = (input: Uint8Array | HexString): V15 => {\n  try {\n    const { metadata } = getAnyMetadata(input)\n    if (metadata.tag !== \"v15\") throw new Error(\"Wrong metadata version\")\n    return metadata.value\n  } catch (e) {\n    throw e || new Error(\"Unable to decode metadata\")\n  }\n}\n"],"names":["metadata"],"mappings":";;AAUA,MAAM,cAAc,KAAM,EAAA,CAAA;AAC1B,MAAM,YAAA,GAAe,OAAO,WAAW,CAAA,CAAA;AACvC,MAAM,iBAAA,GAAoB,KAAM,CAAA,OAAA,EAAS,WAAW,CAAA,CAAA;AAEpD,MAAM,cAAA,GAAiB,CAAC,KAAkC,KAAA;AACxD,EAAI,IAAA;AACF,IAAO,OAAA,QAAA,CAAS,IAAI,KAAK,CAAA,CAAA;AAAA,WAClB,CAAG,EAAA;AAAA,GAAC;AAGb,EAAI,IAAA;AACF,IAAA,OAAO,QAAS,CAAA,GAAA,CAAI,YAAa,CAAA,GAAA,CAAI,KAAK,CAAE,CAAA,CAAA;AAAA,WACrC,CAAG,EAAA;AAAA,GAAC;AAGb,EAAI,IAAA;AACF,IAAA,OAAO,QAAS,CAAA,GAAA,CAAI,WAAY,CAAA,GAAA,CAAI,KAAK,CAAC,CAAA,CAAA;AAAA,WACnC,CAAG,EAAA;AAAA,GAAC;AAGb,EAAI,IAAA;AACF,IAAA,OAAO,SAAS,GAAI,CAAA,iBAAA,CAAkB,IAAI,KAAK,CAAA,CAAE,CAAC,CAAC,CAAA,CAAA;AAAA,WAC5C,CAAG,EAAA;AAAA,GAAC;AAEb,EAAM,MAAA,IAAA,CAAA;AACR,CAAA,CAAA;AAEa,MAAA,WAAA,GAAc,CAAC,KAAuC,KAAA;AACjE,EAAI,IAAA;AACF,IAAA,MAAM,EAAE,QAAA,EAAAA,SAAS,EAAA,GAAI,eAAe,KAAK,CAAA,CAAA;AACzC,IAAA,IAAIA,UAAS,GAAQ,KAAA,KAAA,EAAa,MAAA,IAAI,MAAM,wBAAwB,CAAA,CAAA;AACpE,IAAA,OAAOA,SAAS,CAAA,KAAA,CAAA;AAAA,WACT,CAAG,EAAA;AACV,IAAM,MAAA,CAAA,IAAK,IAAI,KAAA,CAAM,2BAA2B,CAAA,CAAA;AAAA,GAClD;AACF;;;;"}

package/dist/esm/index.mjs

@@ -0,0 +1,3 @@
+export { merkleizeMetadata } from './main.mjs';
+export { extraInfo, extrinsicMetadata, hash, lookup, lookupType, proof } from './codecs.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/esm/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/esm/main.mjs

@@ -0,0 +1,140 @@
+import { Blake3256, compact, u32 } from '@polkadot-api/substrate-bindings';
+import { lookupType, extrinsicMetadata, metadataDigest, extrinsicDec, extraInfo } from './codecs.mjs';
+import { getAccessibleTypes } from './get-accessible-types.mjs';
+import { getLookup } from './get-lookup.mjs';
+import { getMetadata } from './get-metadata.mjs';
+import { compactTypeRefs, mergeUint8, toBytes } from './utils.mjs';
+import { decodeAndCollectKnownLeafs } from './decode-and-collect.mjs';
+import { getProofData } from './proof.mjs';
+
+const merkleizeMetadata = (metadataBytes, info) => {
+  const metadata = getMetadata(metadataBytes);
+  const definitions = new Map(
+    metadata.lookup.map((value) => [value.id, value])
+  );
+  const accessibleTypes = getAccessibleTypes(metadata, 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: metadata.extrinsic.version,
+    addressTy: getTypeRef(metadata.extrinsic.address),
+    callTy: getTypeRef(metadata.extrinsic.call),
+    signatureTy: getTypeRef(metadata.extrinsic.signature),
+    signedExtensions: metadata.extrinsic.signedExtensions.map((se) => ({
+      identifier: se.identifier,
+      includedInExtrinsic: getTypeRef(se.type),
+      includedInSignedData: getTypeRef(se.additionalSigned)
+    }))
+  };
+  const lookup = getLookup(
+    definitions,
+    accessibleTypes,
+    getTypeRef,
+    getPrimitive
+  );
+  const lookupEncoded = lookup.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] = Blake3256(lookupEncoded[i]);
+    for (let i = hashTree.length - 2; i > 0; i -= 2)
+      hashTree[(i - 1) / 2] = 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: Blake3256(extrinsicMetadata.enc(extrinsic)),
+        ...info
+      }
+    };
+    return digested = 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([
+      compact.enc(proofData.leaves.length),
+      ...proofData.leaves,
+      compact.enc(proofData.leafIdxs.length),
+      ...proofData.leafIdxs.map((x) => u32.enc(x)),
+      compact.enc(proofs.length),
+      ...proofs,
+      extrinsicMetadata.enc(extrinsic),
+      extraInfo.enc(info)
+    ]);
+  };
+  const getProofForExtrinsicPayload = (extrinsicPayload) => {
+    const typeRefs = [
+      extrinsic.callTy,
+      ...extrinsic.signedExtensions.map((x) => x.includedInExtrinsic),
+      ...extrinsic.signedExtensions.map((x) => x.includedInSignedData)
+    ];
+    return generateProof(
+      decodeAndCollectKnownLeafs(extrinsicPayload, typeRefs, lookup)
+    );
+  };
+  const getProofForExtrinsicParts = (callData, includedInExtrinsic, includedInSignedData) => {
+    const bytes = mergeUint8(
+      [callData, includedInExtrinsic, includedInSignedData].map(toBytes)
+    );
+    return getProofForExtrinsicPayload(bytes);
+  };
+  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, lookup));
+  };
+  return {
+    digest,
+    getProofForExtrinsic,
+    getProofForExtrinsicParts,
+    getProofForExtrinsicPayload
+  };
+};
+
+export { merkleizeMetadata };
+//# sourceMappingURL=main.mjs.map

package/dist/esm/main.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.mjs","sources":["../../src/main.ts"],"sourcesContent":["import {\n  Blake3256,\n  HexString,\n  compact,\n  u32,\n} from \"@polkadot-api/substrate-bindings\"\nimport {\n  ExtraInfo,\n  ExtrinsicMetadata,\n  LookupValue,\n  MetadataDigest,\n  ScalePrimitive,\n  TypeRef,\n  extraInfo,\n  extrinsicMetadata,\n  lookupType,\n  metadataDigest,\n  extrinsicDec,\n} from \"./codecs\"\nimport { getAccessibleTypes } from \"./get-accessible-types\"\nimport { getLookup } from \"./get-lookup\"\nimport { getMetadata } from \"./get-metadata\"\nimport { compactTypeRefs, mergeUint8, toBytes } from \"./utils\"\nimport { decodeAndCollectKnownLeafs } from \"./decode-and-collect\"\nimport { getProofData } from \"./proof\"\n\nexport interface MetadataMerkleizer {\n  /**\n   * @returns Digest value of the metadata (aka its merkleized root-hash)\n   */\n  digest: () => Uint8Array\n\n  /**\n   * Get proof for an `Extrinsic`.\n   *\n   * @param transaction         Encoded `Extrinsic`, both signed or unsigned.\n   * @param txAdditionalSigned  Optionally collect types for given\n   *                            `additionalSigned` part of signedExtensions.\n   * @returns Encoded `Proof`\n   */\n  getProofForExtrinsic: (\n    transaction: Uint8Array | HexString,\n    txAdditionalSigned?: Uint8Array | HexString,\n  ) => Uint8Array\n\n  /**\n   * Get proof for `ExtrinsicPayload` parts.\n   *\n   * @param callData              Call data of the transaction. It has to be\n   *                              bare; i.e.\n   *                              without prepended compact length.\n   * @param includedInExtrinsic   Extra part of the signed extensions, all of\n   *                              them concatenated.\n   * @param includedInSignedData  Additional signed part of the signed\n   *                              extensions, all of them concatenated.\n   * @returns Encoded `Proof`\n   */\n  getProofForExtrinsicParts: (\n    callData: Uint8Array | HexString,\n    includedInExtrinsic: Uint8Array | HexString,\n    includedInSignedData: Uint8Array | HexString,\n  ) => Uint8Array\n\n  /**\n   * Get proof for `ExtrinsicPayload`.\n   *\n   * @param extrinsicPayload  Call data, extra part of signedExtensions and\n   *                          additional signed part of signedExtensions\n   *                          concatenated. It has to be bare; i.e. without\n   *                          prepended compact length.\n   * @returns Encoded `Proof`\n   */\n  getProofForExtrinsicPayload: (\n    extrinsicPayload: Uint8Array | HexString,\n  ) => Uint8Array\n}\n\nexport const merkleizeMetadata = (\n  metadataBytes: Uint8Array | HexString,\n  info: ExtraInfo,\n): MetadataMerkleizer => {\n  const metadata = getMetadata(metadataBytes)\n\n  const definitions = new Map<number, LookupValue>(\n    metadata.lookup.map((value) => [value.id, value]),\n  )\n  const accessibleTypes = getAccessibleTypes(metadata, definitions)\n  const getPrimitive = (frameId: number): ScalePrimitive[\"tag\"] | null => {\n    const {\n      def: { tag, value },\n    } = definitions.get(frameId)!\n\n    if (tag === \"primitive\") return value.tag\n\n    if ((tag !== \"composite\" && tag !== \"tuple\") || value.length > 1)\n      throw new Error(\"The provided definition doesn't map to a primitive\")\n\n    return value.length === 0\n      ? null // signals `void`\n      : getPrimitive(tag === \"tuple\" ? value[0] : value[0].type)\n  }\n\n  const getTypeRef = (frameId: number): TypeRef => {\n    const { def } = definitions.get(frameId)!\n\n    if (def.tag === \"primitive\") return { tag: def.value.tag, value: undefined }\n\n    if (def.tag === \"compact\") {\n      const primitive = getPrimitive(def.value)\n      const tag = compactTypeRefs[primitive as \"u8\"]\n      if (!tag) throw new Error(\"Invalid primitive for Compact\")\n      return { tag, value: undefined }\n    }\n\n    return accessibleTypes.has(frameId)\n      ? { tag: \"perId\", value: accessibleTypes.get(frameId)! }\n      : { tag: \"void\", value: undefined }\n  }\n\n  const extrinsic: ExtrinsicMetadata = {\n    version: metadata.extrinsic.version,\n    addressTy: getTypeRef(metadata.extrinsic.address),\n    callTy: getTypeRef(metadata.extrinsic.call),\n    signatureTy: getTypeRef(metadata.extrinsic.signature),\n    signedExtensions: metadata.extrinsic.signedExtensions.map((se) => ({\n      identifier: se.identifier,\n      includedInExtrinsic: getTypeRef(se.type),\n      includedInSignedData: getTypeRef(se.additionalSigned),\n    })),\n  }\n\n  const lookup = getLookup(\n    definitions,\n    accessibleTypes,\n    getTypeRef,\n    getPrimitive,\n  )\n  const lookupEncoded = lookup.map(lookupType.enc)\n\n  let hashTree: Array<Uint8Array> | undefined\n  const getHashTree = (): Array<Uint8Array> => {\n    if (hashTree) return hashTree\n\n    if (!lookupEncoded.length) return (hashTree = [new Uint8Array(32).fill(0)])\n\n    hashTree = new Array(lookupEncoded.length * 2 - 1)\n\n    let leavesStartIdx = lookupEncoded.length - 1\n    for (let i = 0; i < lookupEncoded.length; i++)\n      hashTree[leavesStartIdx + i] = Blake3256(lookupEncoded[i])\n\n    for (let i = hashTree.length - 2; i > 0; i -= 2)\n      hashTree[(i - 1) / 2] = Blake3256(\n        mergeUint8([hashTree[i], hashTree[i + 1]]),\n      )\n\n    return hashTree\n  }\n\n  let digested: undefined | Uint8Array\n  const digest = () => {\n    if (digested) return digested\n    const rootLookupHash = getHashTree()[0]\n\n    const digest: MetadataDigest = {\n      tag: \"V1\",\n      value: {\n        typeInformationTreeRoot: rootLookupHash,\n        extrinsicMetadataHash: Blake3256(extrinsicMetadata.enc(extrinsic)),\n        ...info,\n      },\n    }\n\n    return (digested = Blake3256(metadataDigest.enc(digest)))\n  }\n\n  const generateProof = (knownIndexes: number[]) => {\n    const proofData = getProofData(lookupEncoded, knownIndexes)\n\n    const hashTree = getHashTree()\n    const proofs = proofData.proofIdxs.map((idx) => hashTree[idx])\n\n    return mergeUint8([\n      compact.enc(proofData.leaves.length),\n      ...proofData.leaves,\n      compact.enc(proofData.leafIdxs.length),\n      ...proofData.leafIdxs.map((x) => u32.enc(x)),\n      compact.enc(proofs.length),\n      ...proofs,\n      extrinsicMetadata.enc(extrinsic),\n      extraInfo.enc(info),\n    ])\n  }\n\n  const getProofForExtrinsicPayload = (\n    extrinsicPayload: Uint8Array | HexString,\n  ) => {\n    const typeRefs: Array<TypeRef> = [\n      extrinsic.callTy,\n      ...extrinsic.signedExtensions.map((x) => x.includedInExtrinsic),\n      ...extrinsic.signedExtensions.map((x) => x.includedInSignedData),\n    ]\n    return generateProof(\n      decodeAndCollectKnownLeafs(extrinsicPayload, typeRefs, lookup),\n    )\n  }\n\n  const getProofForExtrinsicParts = (\n    callData: Uint8Array | HexString,\n    includedInExtrinsic: Uint8Array | HexString,\n    includedInSignedData: Uint8Array | HexString,\n  ) => {\n    const bytes = mergeUint8(\n      [callData, includedInExtrinsic, includedInSignedData].map(toBytes),\n    )\n    return getProofForExtrinsicPayload(bytes)\n  }\n\n  const getProofForExtrinsic = (\n    transaction: Uint8Array | HexString,\n    txAdditionalSigned?: Uint8Array | HexString,\n  ) => {\n    let [, { version, signed }, bytes] = extrinsicDec(transaction)\n\n    if (version !== extrinsic.version)\n      throw new Error(\"Incorrect extrinsic version\")\n\n    const typeRefs: TypeRef[] = signed\n      ? [\n          extrinsic.addressTy,\n          extrinsic.signatureTy,\n          ...extrinsic.signedExtensions.map((x) => x.includedInExtrinsic),\n          extrinsic.callTy,\n        ]\n      : [extrinsic.callTy]\n\n    if (txAdditionalSigned) {\n      bytes = mergeUint8([bytes, toBytes(txAdditionalSigned)])\n      typeRefs.push(\n        ...extrinsic.signedExtensions.map((x) => x.includedInSignedData),\n      )\n    }\n\n    return generateProof(decodeAndCollectKnownLeafs(bytes, typeRefs, lookup))\n  }\n\n  return {\n    digest,\n    getProofForExtrinsic,\n    getProofForExtrinsicParts,\n    getProofForExtrinsicPayload,\n  }\n}\n"],"names":["digest","hashTree"],"mappings":"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"}