@talismn/scale 1.0.0 → 2.0.0

package/dist/index.mjs

@@ -1,448 +1,347 @@
-// src/papito.ts
-import {
-  getDynamicBuilder,
-  getLookupFn
-} from "@polkadot-api/metadata-builders";
-import {
-  Binary,
-  decAnyMetadata,
-  metadata,
-  unifyMetadata
-} from "@polkadot-api/substrate-bindings";
-import { fromHex, mergeUint8, toHex } from "@polkadot-api/utils";
-var magicNumber = 1635018093;
-
-// src/log.ts
+import { getDynamicBuilder, getDynamicBuilder as getDynamicBuilder$1, getLookupFn, getLookupFn as getLookupFn$1 } from "@polkadot-api/metadata-builders";
+import { Binary, Binary as Binary$1, Blake2128, Blake2128Concat, Blake2256, Blake3256, Blake3256Concat, Twox128, Twox128 as Twox128$1, Twox256, Twox64Concat, decAnyMetadata, decAnyMetadata as decAnyMetadata$1, metadata, unifyMetadata, unifyMetadata as unifyMetadata$1 } from "@polkadot-api/substrate-bindings";
+import { fromHex, mergeUint8, toHex, toHex as toHex$1 } from "@polkadot-api/utils";
 import anylogger from "anylogger";
-
-// package.json
-var package_default = {
-  name: "@talismn/scale",
-  version: "1.0.0",
-  author: "Talisman",
-  homepage: "https://talisman.xyz",
-  license: "GPL-3.0-or-later",
-  publishConfig: {
-    access: "public"
-  },
-  repository: {
-    directory: "packages/scale",
-    type: "git",
-    url: "https://github.com/TalismanSociety/talisman.git"
-  },
-  main: "./dist/index.js",
-  module: "./dist/index.mjs",
-  files: [
-    "dist"
-  ],
-  engines: {
-    node: ">=20"
-  },
-  scripts: {
-    test: "vitest run",
-    clean: "rm -rf dist .turbo node_modules",
-    build: "tsup --silent",
-    typecheck: "tsc --noEmit"
-  },
-  dependencies: {
-    "@polkadot-api/metadata-builders": "0.14.3",
-    "@polkadot-api/substrate-bindings": "0.20.3",
-    "@polkadot-api/utils": "0.4.0",
-    anylogger: "^1.0.11",
-    "scale-ts": "^1.6.1"
-  },
-  devDependencies: {
-    "@talismn/tsconfig": "workspace:*",
-    typescript: "^6.0.3"
-  },
-  types: "./dist/index.d.ts",
-  exports: {
-    ".": {
-      "@talismn/source": "./src/index.ts",
-      import: {
-        types: "./dist/index.d.mts",
-        default: "./dist/index.mjs"
-      },
-      require: {
-        types: "./dist/index.d.ts",
-        default: "./dist/index.js"
-      }
-    }
-  }
-};
-
-// src/log.ts
-var log_default = anylogger(package_default.name);
-
-// src/util/compactMetadata.ts
-var compactMetadata = (anyMetadata, palletsAndItems = [], runtimeApisAndMethods = [], extraKeepTypes = []) => {
-  if (!isCompactableMetadata(anyMetadata))
-    throw new Error(`Metadata version ${anyMetadata.metadata.tag} not supported in compactMetadata`);
-  const metadata2 = anyMetadata.metadata.value;
-  metadata2.pallets = metadata2.pallets.filter(
-    (pallet) => (
-      // keep this pallet if it's listed in `palletsAndItems`
-      palletsAndItems.some(({ pallet: palletName }) => pallet.name === palletName)
-    )
-  );
-  const palletsKeepTypes = palletsAndItems.flatMap(
-    ({ pallet: palletName, constants: constantNames, items: itemNames }) => {
-      const pallet = metadata2.pallets.find((pallet2) => pallet2.name === palletName);
-      if (!pallet) return [];
-      pallet.calls = void 0;
-      pallet.constants = constantNames ? pallet.constants.filter((constant) => constantNames.includes(constant.name)) : [];
-      if ("docs" in pallet) pallet.docs = [];
-      pallet.errors = void 0;
-      pallet.events = void 0;
-      if (!pallet.storage) return [];
-      pallet.storage.items = pallet.storage.items.filter(
-        (item) => itemNames.some((itemName) => item.name === itemName)
-      );
-      return [
-        ...pallet.storage.items.flatMap((item) => [
-          // each type can be either "Plain" or "Map"
-          // if it's "Plain" we only need to get the value type
-          // if it's a "Map" we want to keep both the key AND the value types
-          item.type.tag === "plain" && item.type.value,
-          item.type.tag === "map" && item.type.value.key,
-          item.type.tag === "map" && item.type.value.value
-        ]).filter((type) => typeof type === "number"),
-        ...pallet.constants.flatMap((constant) => constant.type)
-      ];
-    }
-  );
-  let runtimeApisKeepTypes = [];
-  if ("apis" in metadata2) {
-    metadata2.apis = metadata2.apis.filter(
-      (runtimeApi) => runtimeApisAndMethods.some(
-        ({ runtimeApi: runtimeApiName }) => runtimeApi.name === runtimeApiName
-      )
-    );
-    runtimeApisKeepTypes = runtimeApisAndMethods.flatMap(
-      ({ runtimeApi: runtimeApiName, methods: methodNames }) => {
-        const runtimeApi = metadata2.apis.find((runtimeApi2) => runtimeApi2.name === runtimeApiName);
-        if (!runtimeApi) return [];
-        runtimeApi.docs = [];
-        if (!runtimeApi.methods) return [];
-        runtimeApi.methods = runtimeApi.methods.filter(
-          (method) => methodNames.some((methodName) => method.name === methodName)
-        );
-        return runtimeApi.methods.flatMap((method) => [
-          // each method has an array of input types (for the params)
-          ...method.inputs.map((input) => input.type),
-          // and one output type (for the result)
-          method.output
-        ]);
-      }
-    );
-  }
-  const keepTypes = /* @__PURE__ */ new Set([...palletsKeepTypes, ...runtimeApisKeepTypes]);
-  extraKeepTypes?.forEach((type) => keepTypes.add(type));
-  const metadataTysMap = new Map(metadata2.lookup.map((ty) => [ty.id, ty]));
-  addDependentTypes(metadataTysMap, keepTypes, [...keepTypes]);
-  metadata2.lookup = metadata2.lookup.filter((type) => keepTypes.has(type.id));
-  const newTypeIds = /* @__PURE__ */ new Map();
-  metadata2.lookup.forEach((type, index) => newTypeIds.set(type.id, index));
-  const getNewTypeId = (oldTypeId) => {
-    const newTypeId = newTypeIds.get(oldTypeId);
-    if (typeof newTypeId !== "number") log_default.error(`Failed to find newTypeId for type ${oldTypeId}`);
-    return newTypeId ?? 0;
-  };
-  remapTypeIds(metadata2, getNewTypeId);
-  if ("address" in metadata2.extrinsic) metadata2.extrinsic.address = 0;
-  if ("call" in metadata2.extrinsic) metadata2.extrinsic.call = 0;
-  if ("signature" in metadata2.extrinsic) metadata2.extrinsic.signature = 0;
-  if ("extra" in metadata2.extrinsic) metadata2.extrinsic.extra = 0;
-  if ("signedExtensions" in metadata2.extrinsic) metadata2.extrinsic.signedExtensions = [];
-  if ("outerEnums" in metadata2) {
-    metadata2.outerEnums.call = 0;
-    metadata2.outerEnums.error = 0;
-    metadata2.outerEnums.event = 0;
-  }
-};
-var isCompactableMetadata = (metadata2) => {
-  switch (metadata2.metadata.tag) {
-    case "v14":
-    case "v15":
-    case "v16":
-      return true;
-    default:
-      return false;
-  }
+import { Struct, u32, u8 } from "scale-ts";
+//#region src/papito.ts
+/** Constant: https://docs.substrate.io/build/application-development/#metadata-format */
+const magicNumber = 1635018093;
+//#endregion
+//#region src/log.ts
+var log_default = anylogger("@talismn/scale");
+//#endregion
+//#region src/util/compactMetadata.ts
+/**
+* Converts a `Metadata` into a `MiniMetadata`.
+*
+* A `MiniMetadata` only contains the types inside of its `lookup` which are relevant for
+* the storage queries specified in `palletsAndItems`.
+*
+* E.g. if `palletsAndItems` is `{ pallet: "System", items: ["Account"] }`, then only the
+* types used in the `System.Account` storage query will remain inside of metadata.lookups.
+*/
+const compactMetadata = (anyMetadata, palletsAndItems = [], runtimeApisAndMethods = [], extraKeepTypes = []) => {
+	if (!isCompactableMetadata(anyMetadata)) throw new Error(`Metadata version ${anyMetadata.metadata.tag} not supported in compactMetadata`);
+	const metadata = anyMetadata.metadata.value;
+	metadata.pallets = metadata.pallets.filter((pallet) => palletsAndItems.some(({ pallet: palletName }) => pallet.name === palletName));
+	const palletsKeepTypes = palletsAndItems.flatMap(({ pallet: palletName, constants: constantNames, items: itemNames }) => {
+		const pallet = metadata.pallets.find((pallet) => pallet.name === palletName);
+		if (!pallet) return [];
+		pallet.calls = void 0;
+		pallet.constants = constantNames ? pallet.constants.filter((constant) => constantNames.includes(constant.name)) : [];
+		if ("docs" in pallet) pallet.docs = [];
+		pallet.errors = void 0;
+		pallet.events = void 0;
+		if (!pallet.storage) return [];
+		pallet.storage.items = pallet.storage.items.filter((item) => itemNames.some((itemName) => item.name === itemName));
+		return [...pallet.storage.items.flatMap((item) => [
+			item.type.tag === "plain" && item.type.value,
+			item.type.tag === "map" && item.type.value.key,
+			item.type.tag === "map" && item.type.value.value
+		]).filter((type) => typeof type === "number"), ...pallet.constants.flatMap((constant) => constant.type)];
+	});
+	let runtimeApisKeepTypes = [];
+	if ("apis" in metadata) {
+		metadata.apis = metadata.apis.filter((runtimeApi) => runtimeApisAndMethods.some(({ runtimeApi: runtimeApiName }) => runtimeApi.name === runtimeApiName));
+		runtimeApisKeepTypes = runtimeApisAndMethods.flatMap(({ runtimeApi: runtimeApiName, methods: methodNames }) => {
+			const runtimeApi = metadata.apis.find((runtimeApi) => runtimeApi.name === runtimeApiName);
+			if (!runtimeApi) return [];
+			runtimeApi.docs = [];
+			if (!runtimeApi.methods) return [];
+			runtimeApi.methods = runtimeApi.methods.filter((method) => methodNames.some((methodName) => method.name === methodName));
+			return runtimeApi.methods.flatMap((method) => [...method.inputs.map((input) => input.type), method.output]);
+		});
+	}
+	const keepTypes = /* @__PURE__ */ new Set([...palletsKeepTypes, ...runtimeApisKeepTypes]);
+	extraKeepTypes?.forEach((type) => keepTypes.add(type));
+	const metadataTysMap = new Map(metadata.lookup.map((ty) => [ty.id, ty]));
+	addDependentTypes(metadataTysMap, keepTypes, [...keepTypes]);
+	metadata.lookup = metadata.lookup.filter((type) => keepTypes.has(type.id));
+	const newTypeIds = /* @__PURE__ */ new Map();
+	metadata.lookup.forEach((type, index) => newTypeIds.set(type.id, index));
+	const getNewTypeId = (oldTypeId) => {
+		const newTypeId = newTypeIds.get(oldTypeId);
+		if (typeof newTypeId !== "number") log_default.error(`Failed to find newTypeId for type ${oldTypeId}`);
+		return newTypeId ?? 0;
+	};
+	remapTypeIds(metadata, getNewTypeId);
+	if ("address" in metadata.extrinsic) metadata.extrinsic.address = 0;
+	if ("call" in metadata.extrinsic) metadata.extrinsic.call = 0;
+	if ("signature" in metadata.extrinsic) metadata.extrinsic.signature = 0;
+	if ("extra" in metadata.extrinsic) metadata.extrinsic.extra = 0;
+	if ("signedExtensions" in metadata.extrinsic) metadata.extrinsic.signedExtensions = [];
+	if ("outerEnums" in metadata) {
+		metadata.outerEnums.call = 0;
+		metadata.outerEnums.error = 0;
+		metadata.outerEnums.event = 0;
+	}
 };
-var addDependentTypes = (metadataTysMap, keepTypes, types, addedTypes = /* @__PURE__ */ new Set()) => {
-  const addDependentSubTypes = (subTypes) => addDependentTypes(metadataTysMap, keepTypes, subTypes, addedTypes);
-  for (const typeId of types) {
-    const type = metadataTysMap.get(typeId);
-    if (!type) {
-      log_default.warn(`Unable to find type with id ${typeId}`);
-      continue;
-    }
-    if (addedTypes.has(type.id)) continue;
-    keepTypes.add(type.id);
-    addedTypes.add(type.id);
-    const paramTypes = type.params.map((param) => param.type).filter((type2) => typeof type2 === "number");
-    addDependentSubTypes(paramTypes);
-    switch (type.def.tag) {
-      case "array":
-        addDependentSubTypes([type.def.value.type]);
-        break;
-      case "bitSequence":
-        addDependentSubTypes([type.def.value.bitOrderType, type.def.value.bitStoreType]);
-        break;
-      case "compact":
-        addDependentSubTypes([type.def.value]);
-        break;
-      case "composite":
-        addDependentSubTypes(
-          type.def.value.map((field) => field.type).filter((type2) => typeof type2 === "number")
-        );
-        break;
-      case "primitive":
-        break;
-      case "sequence":
-        addDependentSubTypes([type.def.value]);
-        break;
-      case "tuple":
-        addDependentSubTypes(
-          type.def.value.filter((type2) => typeof type2 === "number")
-        );
-        break;
-      case "variant":
-        addDependentSubTypes(
-          type.def.value.flatMap((member) => member.fields.map((field) => field.type)).filter((type2) => typeof type2 === "number")
-        );
-        break;
-      default: {
-        const exhaustiveCheck = type.def;
-        log_default.error(`Unhandled V15Type type ${exhaustiveCheck}`);
-      }
-    }
-  }
+const isCompactableMetadata = (metadata) => {
+	switch (metadata.metadata.tag) {
+		case "v14":
+		case "v15":
+		case "v16": return true;
+		default: return false;
+	}
 };
-var remapTypeIds = (metadata2, getNewTypeId) => {
-  remapLookupTypeIds(metadata2, getNewTypeId);
-  remapStorageTypeIds(metadata2, getNewTypeId);
-  remapRuntimeApisTypeIds(metadata2, getNewTypeId);
+const addDependentTypes = (metadataTysMap, keepTypes, types, addedTypes = /* @__PURE__ */ new Set()) => {
+	const addDependentSubTypes = (subTypes) => addDependentTypes(metadataTysMap, keepTypes, subTypes, addedTypes);
+	for (const typeId of types) {
+		const type = metadataTysMap.get(typeId);
+		if (!type) {
+			log_default.warn(`Unable to find type with id ${typeId}`);
+			continue;
+		}
+		if (addedTypes.has(type.id)) continue;
+		keepTypes.add(type.id);
+		addedTypes.add(type.id);
+		addDependentSubTypes(type.params.map((param) => param.type).filter((type) => typeof type === "number"));
+		switch (type.def.tag) {
+			case "array":
+				addDependentSubTypes([type.def.value.type]);
+				break;
+			case "bitSequence":
+				addDependentSubTypes([type.def.value.bitOrderType, type.def.value.bitStoreType]);
+				break;
+			case "compact":
+				addDependentSubTypes([type.def.value]);
+				break;
+			case "composite":
+				addDependentSubTypes(type.def.value.map((field) => field.type).filter((type) => typeof type === "number"));
+				break;
+			case "primitive": break;
+			case "sequence":
+				addDependentSubTypes([type.def.value]);
+				break;
+			case "tuple":
+				addDependentSubTypes(type.def.value.filter((type) => typeof type === "number"));
+				break;
+			case "variant":
+				addDependentSubTypes(type.def.value.flatMap((member) => member.fields.map((field) => field.type)).filter((type) => typeof type === "number"));
+				break;
+			default: {
+				const exhaustiveCheck = type.def;
+				log_default.error(`Unhandled V15Type type ${exhaustiveCheck}`);
+			}
+		}
+	}
 };
-var remapLookupTypeIds = (metadata2, getNewTypeId) => {
-  for (const type of metadata2.lookup) {
-    type.id = getNewTypeId(type.id);
-    for (const param of type.params) {
-      if (typeof param.type !== "number") continue;
-      param.type = getNewTypeId(param.type);
-    }
-    switch (type.def.tag) {
-      case "array":
-        type.def.value.type = getNewTypeId(type.def.value.type);
-        break;
-      case "bitSequence":
-        type.def.value.bitOrderType = getNewTypeId(type.def.value.bitOrderType);
-        type.def.value.bitStoreType = getNewTypeId(type.def.value.bitStoreType);
-        break;
-      case "compact":
-        type.def.value = getNewTypeId(type.def.value);
-        break;
-      case "composite":
-        for (const field of type.def.value) {
-          if (typeof field.type !== "number") continue;
-          field.type = getNewTypeId(field.type);
-        }
-        break;
-      case "primitive":
-        break;
-      case "sequence":
-        type.def.value = getNewTypeId(type.def.value);
-        break;
-      case "tuple":
-        type.def.value = type.def.value.map((type2) => {
-          if (typeof type2 !== "number") return type2;
-          return getNewTypeId(type2);
-        });
-        break;
-      case "variant":
-        for (const member of type.def.value) {
-          for (const field of member.fields) {
-            if (typeof field.type !== "number") continue;
-            field.type = getNewTypeId(field.type);
-          }
-        }
-        break;
-      default: {
-        const exhaustiveCheck = type.def;
-        log_default.error(`Unhandled V15Type type ${exhaustiveCheck}`);
-      }
-    }
-  }
+const remapTypeIds = (metadata, getNewTypeId) => {
+	remapLookupTypeIds(metadata, getNewTypeId);
+	remapStorageTypeIds(metadata, getNewTypeId);
+	remapRuntimeApisTypeIds(metadata, getNewTypeId);
 };
-var remapStorageTypeIds = (metadata2, getNewTypeId) => {
-  for (const pallet of metadata2.pallets) {
-    for (const item of pallet.storage?.items ?? []) {
-      if (item.type.tag === "plain") item.type.value = getNewTypeId(item.type.value);
-      if (item.type.tag === "map") {
-        item.type.value.key = getNewTypeId(item.type.value.key);
-        item.type.value.value = getNewTypeId(item.type.value.value);
-      }
-    }
-    for (const constant of pallet.constants ?? []) {
-      constant.type = getNewTypeId(constant.type);
-    }
-  }
+const remapLookupTypeIds = (metadata, getNewTypeId) => {
+	for (const type of metadata.lookup) {
+		type.id = getNewTypeId(type.id);
+		for (const param of type.params) {
+			if (typeof param.type !== "number") continue;
+			param.type = getNewTypeId(param.type);
+		}
+		switch (type.def.tag) {
+			case "array":
+				type.def.value.type = getNewTypeId(type.def.value.type);
+				break;
+			case "bitSequence":
+				type.def.value.bitOrderType = getNewTypeId(type.def.value.bitOrderType);
+				type.def.value.bitStoreType = getNewTypeId(type.def.value.bitStoreType);
+				break;
+			case "compact":
+				type.def.value = getNewTypeId(type.def.value);
+				break;
+			case "composite":
+				for (const field of type.def.value) {
+					if (typeof field.type !== "number") continue;
+					field.type = getNewTypeId(field.type);
+				}
+				break;
+			case "primitive": break;
+			case "sequence":
+				type.def.value = getNewTypeId(type.def.value);
+				break;
+			case "tuple":
+				type.def.value = type.def.value.map((type) => {
+					if (typeof type !== "number") return type;
+					return getNewTypeId(type);
+				});
+				break;
+			case "variant":
+				for (const member of type.def.value) for (const field of member.fields) {
+					if (typeof field.type !== "number") continue;
+					field.type = getNewTypeId(field.type);
+				}
+				break;
+			default: {
+				const exhaustiveCheck = type.def;
+				log_default.error(`Unhandled V15Type type ${exhaustiveCheck}`);
+			}
+		}
+	}
 };
-var remapRuntimeApisTypeIds = (metadata2, getNewTypeId) => {
-  for (const runtimeApi of metadata2.apis) {
-    for (const method of runtimeApi.methods ?? []) {
-      for (const input of method.inputs) {
-        input.type = getNewTypeId(input.type);
-      }
-      method.output = getNewTypeId(method.output);
-    }
-  }
+const remapStorageTypeIds = (metadata, getNewTypeId) => {
+	for (const pallet of metadata.pallets) {
+		for (const item of pallet.storage?.items ?? []) {
+			if (item.type.tag === "plain") item.type.value = getNewTypeId(item.type.value);
+			if (item.type.tag === "map") {
+				item.type.value.key = getNewTypeId(item.type.value.key);
+				item.type.value.value = getNewTypeId(item.type.value.value);
+			}
+		}
+		for (const constant of pallet.constants ?? []) constant.type = getNewTypeId(constant.type);
+	}
 };
-
-// src/util/decodeScale.ts
-var decodeScale = (scaleCoder, change, error) => {
-  if (change === null) return null;
-  try {
-    return scaleCoder?.value?.dec(change) ?? null;
-  } catch (cause) {
-    log_default.warn(error ?? `Failed to decode ${change}`, cause);
-    return null;
-  }
+const remapRuntimeApisTypeIds = (metadata, getNewTypeId) => {
+	for (const runtimeApi of metadata.apis) for (const method of runtimeApi.methods ?? []) {
+		for (const input of method.inputs) input.type = getNewTypeId(input.type);
+		method.output = getNewTypeId(method.output);
+	}
 };
-
-// src/util/encodeMetadata.ts
-var encodeMetadata = (metadata2) => toHex(metadata.enc(metadata2));
-
-// src/util/encodeStateKey.ts
-var encodeStateKey = (scaleCoder, error, ...args) => {
-  try {
-    return scaleCoder?.keys?.enc(...args);
-  } catch (cause) {
-    log_default.warn(error ?? `Failed to encode stateKey ${JSON.stringify(args)}`, cause);
-    return;
-  }
+//#endregion
+//#region src/util/decodeScale.ts
+const decodeScale = (scaleCoder, change, error) => {
+	if (change === null) return null;
+	try {
+		return scaleCoder?.value?.dec(change) ?? null;
+	} catch (cause) {
+		log_default.warn(error ?? `Failed to decode ${change}`, cause);
+		return null;
+	}
 };
-
-// src/util/parseMetadataRpc.ts
-import { getDynamicBuilder as getDynamicBuilder2, getLookupFn as getLookupFn2 } from "@polkadot-api/metadata-builders";
-import { decAnyMetadata as decAnyMetadata2, unifyMetadata as unifyMetadata2 } from "@polkadot-api/substrate-bindings";
-var parseMetadataRpc = (metadataRpc) => {
-  const metadata2 = decAnyMetadata2(metadataRpc);
-  const unifiedMetadata = unifyMetadata2(metadata2);
-  const lookupFn = getLookupFn2(unifiedMetadata);
-  const builder = getDynamicBuilder2(lookupFn);
-  return { metadata: metadata2, unifiedMetadata, lookupFn, builder };
+//#endregion
+//#region src/util/encodeMetadata.ts
+const encodeMetadata = (metadata$1) => toHex(metadata.enc(metadata$1));
+//#endregion
+//#region src/util/encodeStateKey.ts
+const encodeStateKey = (scaleCoder, error, ...args) => {
+	try {
+		return scaleCoder?.keys?.enc(...args);
+	} catch (cause) {
+		log_default.warn(error ?? `Failed to encode stateKey ${JSON.stringify(args)}`, cause);
+		return;
+	}
 };
-
-// src/util/getConstantValueFromMetadata.ts
-var getConstantValueFromMetadata = (metadata2, pallet, constant) => {
-  const { builder, unifiedMetadata } = typeof metadata2 === "string" ? parseMetadataRpc(metadata2) : metadata2;
-  return getConstantValueInner(builder, unifiedMetadata, pallet, constant);
+//#endregion
+//#region src/util/parseMetadataRpc.ts
+const parseMetadataRpc = (metadataRpc) => {
+	const metadata = decAnyMetadata$1(metadataRpc);
+	const unifiedMetadata = unifyMetadata$1(metadata);
+	const lookupFn = getLookupFn$1(unifiedMetadata);
+	return {
+		metadata,
+		unifiedMetadata,
+		lookupFn,
+		builder: getDynamicBuilder$1(lookupFn)
+	};
 };
-var getConstantValueInner = (builder, unifiedMetadata, pallet, constant) => {
-  try {
-    const storageCodec = builder.buildConstant(pallet, constant);
-    const encodedValue = unifiedMetadata.pallets.find(({ name }) => name === pallet)?.constants.find(({ name }) => name === constant)?.value;
-    if (!encodedValue) throw new Error(`Constant ${pallet}.${constant} not found`);
-    return storageCodec.dec(encodedValue);
-  } catch (err) {
-    log_default.error("Failed to get constant value from metadata", {
-      err,
-      pallet,
-      constant
-    });
-    throw err;
-  }
+//#endregion
+//#region src/util/getConstantValueFromMetadata.ts
+const getConstantValueFromMetadata = (metadata, pallet, constant) => {
+	const { builder, unifiedMetadata } = typeof metadata === "string" ? parseMetadataRpc(metadata) : metadata;
+	return getConstantValueInner(builder, unifiedMetadata, pallet, constant);
 };
-
-// src/util/getMetadataVersion.ts
-import { Struct, u8, u32 } from "scale-ts";
-var getMetadataVersion = (metadataRpc) => {
-  try {
-    return Struct({
-      magicNumber: u32,
-      version: u8
-    }).dec(metadataRpc).version;
-  } catch {
-    return 0;
-  }
+const getConstantValueInner = (builder, unifiedMetadata, pallet, constant) => {
+	try {
+		const storageCodec = builder.buildConstant(pallet, constant);
+		const encodedValue = unifiedMetadata.pallets.find(({ name }) => name === pallet)?.constants.find(({ name }) => name === constant)?.value;
+		if (!encodedValue) throw new Error(`Constant ${pallet}.${constant} not found`);
+		return storageCodec.dec(encodedValue);
+	} catch (err) {
+		log_default.error("Failed to get constant value from metadata", {
+			err,
+			pallet,
+			constant
+		});
+		throw err;
+	}
 };
-
-// src/util/getStorageKeyPrefix.ts
-import { Twox128 } from "@polkadot-api/substrate-bindings";
-import { toHex as toHex2 } from "@polkadot-api/utils";
-var getStorageKeyPrefix = (palletName, storageName) => {
-  const palletHash = Twox128(new TextEncoder().encode(palletName));
-  const storageHash = Twox128(new TextEncoder().encode(storageName));
-  const combined = new Uint8Array(palletHash.length + storageHash.length);
-  combined.set(palletHash, 0);
-  combined.set(storageHash, palletHash.length);
-  return toHex2(combined);
+//#endregion
+//#region src/util/getMetadataVersion.ts
+/**
+* Extracts the `version` u8 from a SCALE-encoded metadata blob and returns it as a `number`.
+*
+* Only reads the first 40 bytes of the blob.
+*/
+const getMetadataVersion = (metadataRpc) => {
+	try {
+		return Struct({
+			magicNumber: u32,
+			version: u8
+		}).dec(metadataRpc).version;
+	} catch {
+		return 0;
+	}
 };
-
-// src/util/hash.ts
-import {
-  Blake2128,
-  Blake2128Concat,
-  Blake2256,
-  Blake3256,
-  Blake3256Concat,
-  Twox64Concat,
-  Twox128 as Twox1282,
-  Twox256
-} from "@polkadot-api/substrate-bindings";
-
-// src/util/serdePapi.ts
-import { Binary as Binary2 } from "@polkadot-api/substrate-bindings";
-var papiParse = (text) => {
-  const reviver = (_key, value) => {
-    if (typeof value !== "string") return value;
-    if (value.startsWith("bigint:")) return BigInt(value.slice("bigint:".length));
-    if (value.startsWith("u8a:")) return Binary2.fromHex(value.slice("u8a:".length));
-    if (value.startsWith("hex:")) return value.slice("hex:".length);
-    if (value.startsWith("bin:")) return Binary2.toHex(Binary2.fromText(value.slice("bin:".length)));
-    return value;
-  };
-  if (typeof text !== "string") return text;
-  return JSON.parse(text, reviver);
+//#endregion
+//#region src/util/getStorageKeyPrefix.ts
+const getStorageKeyPrefix = (palletName, storageName) => {
+	const palletHash = Twox128$1(new TextEncoder().encode(palletName));
+	const storageHash = Twox128$1(new TextEncoder().encode(storageName));
+	const combined = new Uint8Array(palletHash.length + storageHash.length);
+	combined.set(palletHash, 0);
+	combined.set(storageHash, palletHash.length);
+	return toHex$1(combined);
 };
-var papiStringify = (value, space) => {
-  const replacer = (_key, value2) => {
-    if (typeof value2 === "bigint") return `bigint:${String(value2)}`;
-    if (value2 instanceof Uint8Array) return `u8a:${Binary2.toHex(value2)}`;
-    return value2;
-  };
-  return JSON.stringify(value, replacer, space);
+//#endregion
+//#region src/util/serdePapi.ts
+/**
+* For the substrate-tokens (and other) modules, we configure the `onChainId` field in chaindata to tell the module how to query each token.
+* These queries are made to the tokens pallet.
+* E.g. api.query.Tokens.Account(accountAddress, papiParse(onChainId))
+*
+* The `onChainId` field on chaindata must be a JSON-parseable string, but a decoded papi value can
+* contain types that plain JSON cannot represent. `papiStringify`/`papiParse` are inverse functions
+* that serialise *any* decoded papi value to a deterministic string and back.
+*
+* Only two decoded types are not valid JSON, so only these get a tag — everything else (numbers,
+* objects, and strings, including the `0x…` hex strings papi v2 decodes fixed-size `[u8; N]` fields
+* into) is already JSON and is left untouched:
+*   - `bigint`      → `bigint:<n>`
+*   - `Uint8Array`  → `u8a:0x<hex>`   (papi v2 decodes variable-length `Vec<u8>` to a `Uint8Array`)
+*
+* Note on polkadot-api v2 byte fields. The `Binary` class was removed and the SCALE codecs split
+* byte decoding into two distinct JS types, which `papiParse` must reproduce exactly or the codec
+* silently builds a garbage statekey (→ no balance):
+*   - fixed-size `[u8; N]` (`AccountId32`, `AccountKey20`, `GeneralKey.data`, Erc20 addresses,
+*     Stellar code/issuer, …) → a plain `0x` hex **string** (`SizedHex`). The codec's `.enc`
+*     expects that string. So a fixed-size field is just a JSON string: no tag, round-trips as-is.
+*   - variable-length `Vec<u8>` → a **`Uint8Array`**. The codec's `.enc` expects a `Uint8Array`,
+*     NOT a hex string. Hence the dedicated `u8a:` tag, which `papiParse` restores to a `Uint8Array`.
+*
+* `hex:` and `bin:` are legacy/authoring **input** forms still accepted by `papiParse` (some
+* chaindata token templates are hand-written with them), but `papiStringify` never emits them — it
+* normalises to the bare canonical form. So the canonical output is deterministic and idempotent:
+* `papiStringify(papiParse(canonical)) === canonical`.
+*
+* Some examples (input string → papiParse value):
+* Input: `5`                                            → `5`
+* Input: `{ type: "LiquidCrowdloan", value: 13 }`       → `Enum("LiquidCrowdloan", 13)`
+* Input: `{ type: "NativeToken", value: "bigint:2" }`   → `Enum("NativeToken", 2n)`
+* Input: `{ type: "Erc20", value: "0x07df…bce" }`       → `Enum("Erc20", "0x07df…bce")`        (fixed → string)
+* Input: `{ type: "Erc20", value: "hex:0x07df…bce" }`   → `Enum("Erc20", "0x07df…bce")`        (legacy input)
+* Input: `{ code: "bin:TZS" }`                          → `{ code: "0x545a53" }`               (legacy input)
+* Input: `"u8a:0xdeadbeef"`                             → `Uint8Array([0xde,0xad,0xbe,0xef])`  (variable bytes)
+*/
+const papiParse = (text) => {
+	const reviver = (_key, value) => {
+		if (typeof value !== "string") return value;
+		if (value.startsWith("bigint:")) return BigInt(value.slice(7));
+		if (value.startsWith("u8a:")) return Binary$1.fromHex(value.slice(4));
+		if (value.startsWith("hex:")) return value.slice(4);
+		if (value.startsWith("bin:")) return Binary$1.toHex(Binary$1.fromText(value.slice(4)));
+		return value;
+	};
+	if (typeof text !== "string") return text;
+	return JSON.parse(text, reviver);
 };
-export {
-  Binary,
-  Blake2128,
-  Blake2128Concat,
-  Blake2256,
-  Blake3256,
-  Blake3256Concat,
-  Twox1282 as Twox128,
-  Twox256,
-  Twox64Concat,
-  compactMetadata,
-  decAnyMetadata,
-  decodeScale,
-  encodeMetadata,
-  encodeStateKey,
-  fromHex,
-  getConstantValueFromMetadata,
-  getDynamicBuilder,
-  getLookupFn,
-  getMetadataVersion,
-  getStorageKeyPrefix,
-  magicNumber,
-  mergeUint8,
-  metadata,
-  papiParse,
-  papiStringify,
-  parseMetadataRpc,
-  toHex,
-  unifyMetadata
+const papiStringify = (value, space) => {
+	const replacer = (_key, value) => {
+		if (typeof value === "bigint") return `bigint:${String(value)}`;
+		if (value instanceof Uint8Array) return `u8a:${Binary$1.toHex(value)}`;
+		return value;
+	};
+	return JSON.stringify(value, replacer, space);
 };
+//#endregion
+export { Binary, Blake2128, Blake2128Concat, Blake2256, Blake3256, Blake3256Concat, Twox128, Twox256, Twox64Concat, compactMetadata, decAnyMetadata, decodeScale, encodeMetadata, encodeStateKey, fromHex, getConstantValueFromMetadata, getDynamicBuilder, getLookupFn, getMetadataVersion, getStorageKeyPrefix, magicNumber, mergeUint8, metadata, papiParse, papiStringify, parseMetadataRpc, toHex, unifyMetadata };
+
 //# sourceMappingURL=index.mjs.map