@talismn/scale 0.0.0-pr2277-20251211070508 → 0.0.0-pr2295-20260110031023

package/dist/talismn-scale.esm.js

@@ -1,410 +0,0 @@
-import { getLookupFn, getDynamicBuilder } from '@polkadot-api/metadata-builders';
-export { getDynamicBuilder, getLookupFn } from '@polkadot-api/metadata-builders';
-import { metadata, Binary, decAnyMetadata, unifyMetadata, Twox128 } from '@polkadot-api/substrate-bindings';
-export { Binary, Blake2128, Blake2128Concat, Blake2256, Blake3256, Blake3256Concat, FixedSizeBinary, Twox128, Twox256, Twox64Concat, decAnyMetadata, metadata, unifyMetadata } from '@polkadot-api/substrate-bindings';
-import { toHex } from '@polkadot-api/utils';
-export { fromHex, mergeUint8, toHex } from '@polkadot-api/utils';
-import anylogger from 'anylogger';
-import { Struct, u8, u32 } from 'scale-ts';
-
-/** Constant: https://docs.substrate.io/build/application-development/#metadata-format */
-const magicNumber = 1635018093;
-
-var packageJson = {
-	name: "@talismn/scale"};
-
-var log = anylogger(packageJson.name);
-
-/**
- * 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;
-
-  // remove pallets we don't care about
-  metadata.pallets = metadata.pallets.filter(pallet =>
-  // keep this pallet if it's listed in `palletsAndItems`
-  palletsAndItems.some(({
-    pallet: palletName
-  }) => pallet.name === palletName));
-
-  // remove fields we don't care about from each pallet, and extract types for each storage item we care about
-  const palletsKeepTypes = palletsAndItems.flatMap(({
-    pallet: palletName,
-    constants: constantNames,
-    items: itemNames
-  }) => {
-    const pallet = metadata.pallets.find(pallet => pallet.name === palletName);
-    if (!pallet) return [];
-
-    // remove pallet fields we don't care about
-    pallet.calls = undefined;
-    pallet.constants = constantNames ? pallet.constants.filter(constant => constantNames.includes(constant.name)) : [];
-    // v15 (NOT v14) has docs
-    if ("docs" in pallet) pallet.docs = [];
-    pallet.errors = undefined;
-    pallet.events = undefined;
-    if (!pallet.storage) return [];
-
-    // filter and extract storage items we care about
-    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)];
-  });
-
-  // remove runtime apis we don't care about
-  let runtimeApisKeepTypes = [];
-  if ("apis" in metadata) {
-    // metadata is v15 (NOT v14)
-
-    // keep this api if it's listed in `runtimeApisAndMethods`
-    metadata.apis = metadata.apis.filter(runtimeApi => runtimeApisAndMethods.some(({
-      runtimeApi: runtimeApiName
-    }) => runtimeApi.name === runtimeApiName));
-
-    // remove methods we don't care about from each runtime api, and extract types for each call's params and result
-    runtimeApisKeepTypes = runtimeApisAndMethods.flatMap(({
-      runtimeApi: runtimeApiName,
-      methods: methodNames
-    }) => {
-      const runtimeApi = metadata.apis.find(runtimeApi => runtimeApi.name === runtimeApiName);
-      if (!runtimeApi) return [];
-
-      // remove runtime fields we don't care about
-      runtimeApi.docs = [];
-      if (!runtimeApi.methods) return [];
-
-      // filter and extract methods we care about
-      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]);
-    });
-  }
-
-  // this is a set of type ids which we plan to keep in our compacted metadata
-  // anything not in this set will be deleted
-  // we start off with just the types of the state calls we plan to make,
-  // then we run those types through a function (addDependentTypes) which will also include
-  // all of the types which those types depend on - recursively
-  const keepTypes = new Set([...palletsKeepTypes, ...runtimeApisKeepTypes]);
-  extraKeepTypes?.forEach(type => keepTypes.add(type));
-
-  // recursively find all the types which our keepTypes depend on and add them to the keepTypes set
-  const metadataTysMap = new Map(metadata.lookup.map(ty => [ty.id, ty]));
-  addDependentTypes(metadataTysMap, keepTypes, [...keepTypes]);
-
-  // ditch the types we aren't keeping
-  metadata.lookup = metadata.lookup.filter(type => keepTypes.has(type.id));
-
-  // update all type ids to be sequential (fill the gaps left by the deleted types)
-  const newTypeIds = 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.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 is v15 (NOT v14)
-    metadata.outerEnums.call = 0;
-    metadata.outerEnums.error = 0;
-    metadata.outerEnums.event = 0;
-  }
-};
-const isCompactableMetadata = metadata => {
-  switch (metadata.metadata.tag) {
-    case "v14":
-    case "v15":
-    case "v16":
-      return true;
-    default:
-      return false;
-  }
-};
-const addDependentTypes = (metadataTysMap, keepTypes, types,
-// Prevent stack overflow when a type references itself
-addedTypes = new Set()) => {
-  const addDependentSubTypes = subTypes => addDependentTypes(metadataTysMap, keepTypes, subTypes, addedTypes);
-  for (const typeId of types) {
-    const type = metadataTysMap.get(typeId);
-    if (!type) {
-      log.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(type => typeof type === "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(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:
-        {
-          // force compilation error if any types don't have a case
-          const exhaustiveCheck = type.def;
-          log.error(`Unhandled V15Type type ${exhaustiveCheck}`);
-        }
-    }
-  }
-};
-const remapTypeIds = (metadata, getNewTypeId) => {
-  remapLookupTypeIds(metadata, getNewTypeId);
-  remapStorageTypeIds(metadata, getNewTypeId);
-  remapRuntimeApisTypeIds(metadata, getNewTypeId);
-};
-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:
-        {
-          // force compilation error if any types don't have a case
-          const exhaustiveCheck = type.def;
-          log.error(`Unhandled V15Type type ${exhaustiveCheck}`);
-        }
-    }
-  }
-};
-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);
-    }
-  }
-};
-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);
-    }
-  }
-};
-
-const decodeScale = (scaleCoder, change, error) => {
-  if (change === null) return null;
-  try {
-    return scaleCoder?.value?.dec(change) ?? null;
-  } catch (cause) {
-    log.warn(error ?? `Failed to decode ${change}`, cause);
-    return null;
-  }
-};
-
-const encodeMetadata = metadata$1 => toHex(metadata.enc(metadata$1));
-
-const encodeStateKey = (scaleCoder, error, ...args) => {
-  try {
-    return scaleCoder?.keys?.enc(...args);
-  } catch (cause) {
-    log.warn(error ?? `Failed to encode stateKey ${JSON.stringify(args)}`, cause);
-    return;
-  }
-};
-
-/**
- * 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;
-  }
-};
-
-/**
- * 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 for some SCALE types (especially the Binary type) we must
- * use specific `polkadot-api` classes to handle SCALE-encoding the statekey.
- *
- * Some examples:
- * Input: `5`
- * Output: `5`
- *
- * Input: `{ type: "DexShare", value: [ { type: "Token", value: { type: "ACA" } }, { type: "Token", value: { type: "AUSD" } } ] }`
- * Output: `Enum("DexShare", [Enum("Token", Enum("ACA")), Enum("Token", Enum("AUSD"))])`
- *
- * Input: `{ type: "LiquidCrowdloan", value: 13 }`
- * Output: `Enum("LiquidCrowdloan", 13)`
- *
- * Input: `{ type: "NativeToken", value: "bigint:2" }`
- * Output: `Enum("NativeToken", 2n)`
- *
- * Input: `{ type: "Erc20", value: "hex:0x07df96d1341a7d16ba1ad431e2c847d978bc2bce" }`
- * Output: `Enum("Erc20", Binary.fromHex("0x07df96d1341a7d16ba1ad431e2c847d978bc2bce"))`
- *
- * Input: `{ type: "Stellar", value: { code: "bin:TZS", issuer: "hex:0x34c94b2a4ba9e8b57b22547dcbb30f443c4cb02da3829a89aa1bd4780e4466ba" } }`
- * Output: `Enum("Stellar", { code: Binary.fromText("TZS"), issuer: Binary.fromHex("0x34c94b2a4ba9e8b57b22547dcbb30f443c4cb02da3829a89aa1bd4780e4466ba") })`
- */
-const papiParse = text => {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const reviver = (_key, value) => {
-    if (typeof value !== "string") return value;
-    if (value.startsWith("bigint:")) return BigInt(value.slice("bigint:".length));
-    if (value.startsWith("hex:")) return Binary.fromHex(value.slice("hex:".length));
-    if (value.startsWith("bin:")) return Binary.fromText(value.slice("bin:".length));
-    return value;
-  };
-  if (typeof text !== "string") return text;
-  return JSON.parse(text, reviver);
-};
-const papiStringify = (value, space) => {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const replacer = (_key, value) => {
-    if (typeof value === "bigint") return `bigint:${String(value)}`;
-    if (value instanceof Binary) return `hex:${value.asHex()}`;
-    return value;
-  };
-  return JSON.stringify(value, replacer, space);
-};
-
-const parseMetadataRpc = metadataRpc => {
-  const metadata = decAnyMetadata(metadataRpc);
-  const unifiedMetadata = unifyMetadata(metadata);
-  const lookupFn = getLookupFn(unifiedMetadata);
-  const builder = getDynamicBuilder(lookupFn);
-  return {
-    metadata,
-    unifiedMetadata,
-    lookupFn,
-    builder
-  };
-};
-
-const getStorageKeyPrefix = (palletName, storageName) => {
-  const palletHash = Twox128(new TextEncoder().encode(palletName));
-  const storageHash = Twox128(new TextEncoder().encode(storageName));
-
-  // Concatenate and convert to hex
-  const combined = new Uint8Array(palletHash.length + storageHash.length);
-  combined.set(palletHash, 0);
-  combined.set(storageHash, palletHash.length);
-  return toHex(combined);
-};
-
-const getConstantValueFromMetadata = (metadata, pallet, constant) => {
-  const {
-    builder,
-    unifiedMetadata
-  } = typeof metadata === "string" ? parseMetadataRpc(metadata) : metadata;
-  return getConstantValueInner(builder, unifiedMetadata, pallet, constant);
-};
-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.error("Failed to get constant value from metadata", {
-      err,
-      pallet,
-      constant
-    });
-    throw err;
-  }
-};
-
-export { compactMetadata, decodeScale, encodeMetadata, encodeStateKey, getConstantValueFromMetadata, getMetadataVersion, getStorageKeyPrefix, magicNumber, papiParse, papiStringify, parseMetadataRpc };