@polkadot-api/merkleize-metadata 1.1.0 → 1.1.2

package/dist/index.js

@@ -1,160 +1,127 @@
-"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);
+'use strict';
 
-// 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");
+var substrateBindings = require('@polkadot-api/substrate-bindings');
+var utils = require('@polkadot-api/utils');
 
-// 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
+const extraInfoInner = {
+  specVersion: substrateBindings.u32,
+  specName: substrateBindings.str,
+  base58Prefix: substrateBindings.u16,
+  decimals: substrateBindings.u8,
+  tokenSymbol: substrateBindings.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)({
+const extraInfo = substrateBindings.Struct(extraInfoInner);
+const hash = substrateBindings.Bytes(32);
+const metadataDigest = substrateBindings.ScaleEnum({
+  V0: substrateBindings._void,
+  V1: substrateBindings.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
+substrateBindings.ScaleEnum({
+  bool: substrateBindings._void,
+  char: substrateBindings._void,
+  str: substrateBindings._void,
+  u8: substrateBindings._void,
+  u16: substrateBindings._void,
+  u32: substrateBindings._void,
+  u64: substrateBindings._void,
+  u128: substrateBindings._void,
+  u256: substrateBindings._void,
+  i8: substrateBindings._void,
+  i16: substrateBindings._void,
+  i32: substrateBindings._void,
+  i64: substrateBindings._void,
+  i128: substrateBindings._void,
+  i256: substrateBindings._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
+const typeRef = substrateBindings.ScaleEnum({
+  bool: substrateBindings._void,
+  char: substrateBindings._void,
+  str: substrateBindings._void,
+  u8: substrateBindings._void,
+  u16: substrateBindings._void,
+  u32: substrateBindings._void,
+  u64: substrateBindings._void,
+  u128: substrateBindings._void,
+  u256: substrateBindings._void,
+  i8: substrateBindings._void,
+  i16: substrateBindings._void,
+  i32: substrateBindings._void,
+  i64: substrateBindings._void,
+  i128: substrateBindings._void,
+  i256: substrateBindings._void,
+  compactU8: substrateBindings._void,
+  compactU16: substrateBindings._void,
+  compactU32: substrateBindings._void,
+  compactU64: substrateBindings._void,
+  compactU128: substrateBindings._void,
+  compactU256: substrateBindings._void,
+  void: substrateBindings._void,
+  perId: substrateBindings.compactNumber
 });
-var field = (0, import_substrate_bindings.Struct)({
-  name: (0, import_substrate_bindings.Option)(import_substrate_bindings.str),
+const field = substrateBindings.Struct({
+  name: substrateBindings.Option(substrateBindings.str),
   ty: typeRef,
-  typeName: (0, import_substrate_bindings.Option)(import_substrate_bindings.str)
+  typeName: substrateBindings.Option(substrateBindings.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
+const typeDef = substrateBindings.ScaleEnum({
+  composite: substrateBindings.Vector(field),
+  enumeration: substrateBindings.Struct({
+    name: substrateBindings.str,
+    fields: substrateBindings.Vector(field),
+    index: substrateBindings.compactNumber
   }),
   sequence: typeRef,
-  array: (0, import_substrate_bindings.Struct)({
-    len: import_substrate_bindings.u32,
+  array: substrateBindings.Struct({
+    len: substrateBindings.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
+  tuple: substrateBindings.Vector(typeRef),
+  bitSequence: substrateBindings.Struct({
+    numBytes: substrateBindings.u8,
+    leastSignificantBitFirst: substrateBindings.bool
   })
 });
-var lookupType = (0, import_substrate_bindings.Struct)({
-  path: (0, import_substrate_bindings.Vector)(import_substrate_bindings.str),
+const lookupType = substrateBindings.Struct({
+  path: substrateBindings.Vector(substrateBindings.str),
   typeDef,
-  typeId: import_substrate_bindings.compactNumber
+  typeId: substrateBindings.compactNumber
 });
-var lookup = (0, import_substrate_bindings.Vector)(lookupType);
-var extrinsicMetadata = (0, import_substrate_bindings.Struct)({
-  version: import_substrate_bindings.u8,
+const lookup = substrateBindings.Vector(lookupType);
+const extrinsicMetadata = substrateBindings.Struct({
+  version: substrateBindings.u8,
   addressTy: typeRef,
   callTy: typeRef,
   signatureTy: typeRef,
-  signedExtensions: (0, import_substrate_bindings.Vector)(
-    (0, import_substrate_bindings.Struct)({
-      identifier: import_substrate_bindings.str,
+  signedExtensions: substrateBindings.Vector(
+    substrateBindings.Struct({
+      identifier: substrateBindings.str,
       includedInExtrinsic: typeRef,
       includedInSignedData: typeRef
     })
   )
 });
-var versionDecoder = (0, import_substrate_bindings.enhanceDecoder)(import_substrate_bindings.u8[1], (value) => ({
+const versionDecoder = substrateBindings.enhanceDecoder(substrateBindings.u8[1], (value) => ({
   version: value & ~(1 << 7),
   signed: !!(value & 1 << 7)
 }));
-var extrinsicDec = import_substrate_bindings.Tuple.dec(
-  import_substrate_bindings.compact[1],
+const extrinsicDec = substrateBindings.Tuple.dec(
+  substrateBindings.compact[1],
   versionDecoder,
-  (0, import_substrate_bindings.Bytes)(Infinity)[1]
+  substrateBindings.Bytes(Infinity)[1]
 );
-var proof = (0, import_substrate_bindings.Struct)({
+const proof = substrateBindings.Struct({
   leaves: lookup,
-  leafIdxs: (0, import_substrate_bindings.Vector)(import_substrate_bindings.u32),
-  proofs: (0, import_substrate_bindings.Vector)(hash),
+  leafIdxs: substrateBindings.Vector(substrateBindings.u32),
+  proofs: substrateBindings.Vector(hash),
   extrinsic: extrinsicMetadata,
   info: extraInfo
 });
 
-// src/get-accessible-types.ts
-var getAccessibleTypes = (metadata2, definitions) => {
+const getAccessibleTypes = (metadata, definitions) => {
   const types = /* @__PURE__ */ new Set();
   const collectTypesFromId = (id) => {
     if (types.has(id)) return;
@@ -193,10 +160,10 @@ var getAccessibleTypes = (metadata2, definitions) => {
         types.add(id);
     }
   };
-  collectTypesFromId(metadata2.extrinsic.call);
-  collectTypesFromId(metadata2.extrinsic.address);
-  collectTypesFromId(metadata2.extrinsic.signature);
-  metadata2.extrinsic.signedExtensions.forEach(({ type, additionalSigned }) => {
+  collectTypesFromId(metadata.extrinsic.call);
+  collectTypesFromId(metadata.extrinsic.address);
+  collectTypesFromId(metadata.extrinsic.signature);
+  metadata.extrinsic.signedExtensions.forEach(({ type, additionalSigned }) => {
     collectTypesFromId(type);
     collectTypesFromId(additionalSigned);
   });
@@ -204,14 +171,13 @@ var getAccessibleTypes = (metadata2, definitions) => {
   return new Map(sortedTypes.map((value, idx) => [value, idx]));
 };
 
-// src/get-lookup.ts
-var bitSequenceBytes = {
+const bitSequenceBytes = {
   u8: 1,
   u16: 2,
   u32: 4,
   u64: 8
 };
-var constructTypeDef = (definitions, getTypeRef, getPrimitive, frameId) => {
+const constructTypeDef = (definitions, getTypeRef, getPrimitive, frameId) => {
   const {
     def: { tag, value }
   } = definitions.get(frameId);
@@ -283,16 +249,16 @@ var constructTypeDef = (definitions, getTypeRef, getPrimitive, frameId) => {
   }
   throw new Error(`FrameId(${frameId}) should have been filtered out`);
 };
-var getLookup = (definitions, accessibleTypes, getTypeRef, getPrimitive) => {
+const getLookup = (definitions, accessibleTypes, getTypeRef, getPrimitive) => {
   const typeTree = [];
   [...accessibleTypes.entries()].forEach(([frameId, typeId]) => {
     const { path } = definitions.get(frameId);
     constructTypeDef(definitions, getTypeRef, getPrimitive, frameId).forEach(
-      (typeDef2) => {
+      (typeDef) => {
         typeTree.push({
           path,
           typeId,
-          typeDef: typeDef2
+          typeDef
         });
       }
     );
@@ -306,31 +272,29 @@ var getLookup = (definitions, accessibleTypes, getTypeRef, getPrimitive) => {
   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) => {
+const opaqueBytes = substrateBindings.Bytes();
+const optionOpaque = substrateBindings.Option(opaqueBytes);
+const opaqueOpaqueBytes = substrateBindings.Tuple(substrateBindings.compact, opaqueBytes);
+const getAnyMetadata = (input) => {
   try {
-    return import_substrate_bindings2.metadata.dec(input);
+    return substrateBindings.metadata.dec(input);
   } catch (_) {
   }
   try {
-    return import_substrate_bindings2.metadata.dec(optionOpaque.dec(input));
+    return substrateBindings.metadata.dec(optionOpaque.dec(input));
   } catch (_) {
   }
   try {
-    return import_substrate_bindings2.metadata.dec(opaqueBytes.dec(input));
+    return substrateBindings.metadata.dec(opaqueBytes.dec(input));
   } catch (_) {
   }
   try {
-    return import_substrate_bindings2.metadata.dec(opaqueOpaqueBytes.dec(input)[1]);
+    return substrateBindings.metadata.dec(opaqueOpaqueBytes.dec(input)[1]);
   } catch (_) {
   }
   throw null;
 };
-var getMetadata = (input) => {
+const getMetadata = (input) => {
   try {
     const { metadata: metadata2 } = getAnyMetadata(input);
     if (metadata2.tag !== "v15") throw new Error("Wrong metadata version");
@@ -340,9 +304,7 @@ var getMetadata = (input) => {
   }
 };
 
-// src/utils.ts
-var import_utils = require("@polkadot-api/utils");
-var mergeUint8 = (inputs) => {
+const mergeUint8 = (inputs) => {
   const len = inputs.length;
   let totalLen = 0;
   for (let i = 0; i < len; i++) totalLen += inputs[i].byteLength;
@@ -354,8 +316,8 @@ var mergeUint8 = (inputs) => {
   }
   return result;
 };
-var toBytes = (input) => typeof input === "string" ? (0, import_utils.fromHex)(input) : input;
-var compactTypeRefs = {
+const toBytes = (input) => typeof input === "string" ? utils.fromHex(input) : input;
+const compactTypeRefs = {
   null: "void",
   u8: "compactU8",
   u16: "compactU16",
@@ -365,49 +327,47 @@ var compactTypeRefs = {
   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
+const typeRefDecoders = {
+  bool: substrateBindings.u8,
+  char: substrateBindings.u8,
+  str: substrateBindings.str,
+  u8: substrateBindings.u8,
+  u16: substrateBindings.u16,
+  u32: substrateBindings.u32,
+  u64: substrateBindings.u64,
+  u128: substrateBindings.u128,
+  u256: substrateBindings.u256,
+  i8: substrateBindings.i8,
+  i16: substrateBindings.i16,
+  i32: substrateBindings.i32,
+  i64: substrateBindings.i64,
+  i128: substrateBindings.i128,
+  i256: substrateBindings.i256,
+  void: substrateBindings._void,
+  compactU8: substrateBindings.compact,
+  compactU16: substrateBindings.compact,
+  compactU32: substrateBindings.compact,
+  compactU64: substrateBindings.compact,
+  compactU128: substrateBindings.compact,
+  compactU256: substrateBindings.compact
 };
-var innerDecodeAndCollect = (input, typeRef2, idToLookups, lookup2, collected) => {
-  if (typeRef2.tag !== "perId") {
-    typeRefDecoders[typeRef2.tag][1](input);
+const innerDecodeAndCollect = (input, typeRef, idToLookups, lookup, collected) => {
+  if (typeRef.tag !== "perId") {
+    typeRefDecoders[typeRef.tag][1](input);
     return;
   }
-  const handleTypeRef = (typeRef3) => {
-    innerDecodeAndCollect(input, typeRef3, idToLookups, lookup2, collected);
+  const handleTypeRef = (typeRef2) => {
+    innerDecodeAndCollect(input, typeRef2, idToLookups, lookup, collected);
   };
-  const lookupIdxs = idToLookups.get(typeRef2.value);
+  const lookupIdxs = idToLookups.get(typeRef.value);
   const [currentIdx] = lookupIdxs;
-  const current = lookup2[currentIdx];
+  const current = lookup[currentIdx];
   if (lookupIdxs.length === 1) collected.add(currentIdx);
   switch (current.typeDef.tag) {
     case "enumeration": {
-      const selectedIdx = import_substrate_bindings3.u8.dec(input);
+      const selectedIdx = substrateBindings.u8.dec(input);
       const [selected, collectedIdx] = lookupIdxs.map(
-        (lookupIdx) => [lookup2[lookupIdx].typeDef, lookupIdx]
+        (lookupIdx) => [lookup[lookupIdx].typeDef, lookupIdx]
       ).find(([x]) => x.value.index === selectedIdx);
       collected.add(collectedIdx);
       selected.value.fields.forEach(({ ty }) => {
@@ -416,7 +376,7 @@ var innerDecodeAndCollect = (input, typeRef2, idToLookups, lookup2, collected) =
       break;
     }
     case "sequence": {
-      const len = import_substrate_bindings3.compact.dec(input);
+      const len = substrateBindings.compact.dec(input);
       for (let i = 0; i < len; i++) handleTypeRef(current.typeDef.value);
       break;
     }
@@ -439,27 +399,26 @@ var innerDecodeAndCollect = (input, typeRef2, idToLookups, lookup2, collected) =
       throw new Error("bitSequence is not supported");
   }
 };
-var decodeAndCollectKnownLeafs = (data, typeRefs, lookup2) => {
+const decodeAndCollectKnownLeafs = (data, typeRefs, lookup) => {
   let input = new Uint8Array();
-  (0, import_substrate_bindings3.createDecoder)((_input) => {
+  substrateBindings.createDecoder((_input) => {
     input = _input;
   })(data);
   const idToLookups = /* @__PURE__ */ new Map();
-  lookup2.forEach((lookup3, idx) => {
-    const arr = idToLookups.get(lookup3.typeId);
+  lookup.forEach((lookup2, idx) => {
+    const arr = idToLookups.get(lookup2.typeId);
     if (arr) arr.push(idx);
-    else idToLookups.set(lookup3.typeId, [idx]);
+    else idToLookups.set(lookup2.typeId, [idx]);
   });
   const result = /* @__PURE__ */ new Set();
-  typeRefs.forEach((typeRef2) => {
-    innerDecodeAndCollect(input, typeRef2, idToLookups, lookup2, result);
+  typeRefs.forEach((typeRef) => {
+    innerDecodeAndCollect(input, typeRef, idToLookups, lookup, 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;
+const getLevelFromIdx = (idx) => Math.log2(idx + 1) | 0;
+const getAncestorIdx = (from, nLevels) => (from + 1 >> nLevels) - 1;
 function getProofData(leaves, knownLeavesIdxs) {
   const knownLeaves = knownLeavesIdxs.map((idx) => leaves[idx]);
   const startingIdx = leaves.length - 1;
@@ -503,13 +462,12 @@ function getProofData(leaves, knownLeavesIdxs) {
   };
 }
 
-// src/main.ts
-var merkleizeMetadata = (metadataBytes, info) => {
-  const metadata2 = getMetadata(metadataBytes);
+const merkleizeMetadata = (metadataBytes, info) => {
+  const metadata = getMetadata(metadataBytes);
   const definitions = new Map(
-    metadata2.lookup.map((value) => [value.id, value])
+    metadata.lookup.map((value) => [value.id, value])
   );
-  const accessibleTypes = getAccessibleTypes(metadata2, definitions);
+  const accessibleTypes = getAccessibleTypes(metadata, definitions);
   const getPrimitive = (frameId) => {
     const {
       def: { tag, value }
@@ -531,23 +489,23 @@ var merkleizeMetadata = (metadataBytes, info) => {
     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) => ({
+    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 lookup2 = getLookup(
+  const lookup = getLookup(
     definitions,
     accessibleTypes,
     getTypeRef,
     getPrimitive
   );
-  const lookupEncoded = lookup2.map(lookupType.enc);
+  const lookupEncoded = lookup.map(lookupType.enc);
   let hashTree;
   const getHashTree = () => {
     if (hashTree) return hashTree;
@@ -555,9 +513,9 @@ var merkleizeMetadata = (metadataBytes, info) => {
     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]);
+      hashTree[leavesStartIdx + i] = substrateBindings.Blake3256(lookupEncoded[i]);
     for (let i = hashTree.length - 2; i > 0; i -= 2)
-      hashTree[(i - 1) / 2] = (0, import_substrate_bindings4.Blake3256)(
+      hashTree[(i - 1) / 2] = substrateBindings.Blake3256(
         mergeUint8([hashTree[i], hashTree[i + 1]])
       );
     return hashTree;
@@ -570,22 +528,22 @@ var merkleizeMetadata = (metadataBytes, info) => {
       tag: "V1",
       value: {
         typeInformationTreeRoot: rootLookupHash,
-        extrinsicMetadataHash: (0, import_substrate_bindings4.Blake3256)(extrinsicMetadata.enc(extrinsic)),
+        extrinsicMetadataHash: substrateBindings.Blake3256(extrinsicMetadata.enc(extrinsic)),
         ...info
       }
     };
-    return digested = (0, import_substrate_bindings4.Blake3256)(metadataDigest.enc(digest2));
+    return digested = substrateBindings.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),
+      substrateBindings.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),
+      substrateBindings.compact.enc(proofData.leafIdxs.length),
+      ...proofData.leafIdxs.map((x) => substrateBindings.u32.enc(x)),
+      substrateBindings.compact.enc(proofs.length),
       ...proofs,
       extrinsicMetadata.enc(extrinsic),
       extraInfo.enc(info)
@@ -598,7 +556,7 @@ var merkleizeMetadata = (metadataBytes, info) => {
       ...extrinsic.signedExtensions.map((x) => x.includedInSignedData)
     ];
     return generateProof(
-      decodeAndCollectKnownLeafs(extrinsicPayload, typeRefs, lookup2)
+      decodeAndCollectKnownLeafs(extrinsicPayload, typeRefs, lookup)
     );
   };
   const getProofForExtrinsicParts = (callData, includedInExtrinsic, includedInSignedData) => {
@@ -623,7 +581,7 @@ var merkleizeMetadata = (metadataBytes, info) => {
         ...extrinsic.signedExtensions.map((x) => x.includedInSignedData)
       );
     }
-    return generateProof(decodeAndCollectKnownLeafs(bytes, typeRefs, lookup2));
+    return generateProof(decodeAndCollectKnownLeafs(bytes, typeRefs, lookup));
   };
   return {
     digest,
@@ -632,4 +590,12 @@ var merkleizeMetadata = (metadataBytes, info) => {
     getProofForExtrinsicPayload
   };
 };
-//# sourceMappingURL=index.js.map
+
+exports.extraInfo = extraInfo;
+exports.extrinsicMetadata = extrinsicMetadata;
+exports.hash = hash;
+exports.lookup = lookup;
+exports.lookupType = lookupType;
+exports.merkleizeMetadata = merkleizeMetadata;
+exports.proof = proof;
+//# sourceMappingURL=index.js.map