123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139

import type { ExtDef } from 'https://deno.land/x/polkadot@0.2.33/types/extrinsic/signedExtensions/types.ts';import type { Hash } from 'https://deno.land/x/polkadot@0.2.33/types/interfaces/index.ts';import type { ChainUpgradeVersion, CodecHasher, DefinitionRpc, DefinitionRpcSub, DefinitionsCall, OverrideModuleType, OverrideVersionedType, Registry, RegistryTypes } from 'https://deno.land/x/polkadot@0.2.33/types/types/index.ts';import type { Text } from 'https://deno.land/x/polkadot@0.2.33/types-codec/mod.ts';import type { BN } from 'https://deno.land/x/polkadot@0.2.33/util/mod.ts';
import { bnToBn, objectSpread } from 'https://deno.land/x/polkadot@0.2.33/util/mod.ts';
import typesChain from './chain/index.ts';import typesSpec from './spec/index.ts';import upgrades from './upgrades/index.ts';
/** * @description Perform the callback function using the stringified spec/chain * @internal * */function withNames <T> (chainName: Text | string, specName: Text | string, fn: (c: string, s: string) => T): T {  return fn(chainName.toString(), specName.toString());}
/** * @descriptionFflatten a VersionedType[] into a Record<string, string> * @internal * */function filterVersions (versions: OverrideVersionedType[] = [], specVersion: number): RegistryTypes {  return versions    .filter(({ minmax: [min, max] }) =>      (min === undefined || min === null || specVersion >= min) &&      (max === undefined || max === null || specVersion <= max)    )    .reduce((result: RegistryTypes, { types }) =>      objectSpread<RegistryTypes>(result, types), {}    );}
/** * @description Based on the chain and runtimeVersion, get the applicable signed extensions (ready for registration) */export function getSpecExtensions ({ knownTypes }: Registry, chainName: Text | string, specName: Text | string): ExtDef {  return withNames(chainName, specName, (c, s) =>    objectSpread({},      knownTypes.typesBundle?.spec?.[s]?.signedExtensions,      knownTypes.typesBundle?.chain?.[c]?.signedExtensions    )  );}
/** * @description Based on the chain and runtimeVersion, get the applicable types (ready for registration) */export function getSpecTypes ({ knownTypes }: Registry, chainName: Text | string, specName: Text | string, specVersion: bigint | BN | number): RegistryTypes {  const _specVersion = bnToBn(specVersion).toNumber();
  return withNames(chainName, specName, (c, s) =>    // The order here is always, based on -    //   - spec then chain    //   - typesBundle takes higher precedence    //   - types is the final catch-all override    objectSpread({},      filterVersions(typesSpec[s], _specVersion),      filterVersions(typesChain[c], _specVersion),      filterVersions(knownTypes.typesBundle?.spec?.[s]?.types, _specVersion),      filterVersions(knownTypes.typesBundle?.chain?.[c]?.types, _specVersion),      knownTypes.typesSpec?.[s],      knownTypes.typesChain?.[c],      knownTypes.types    )  );}
/** * @description Based on the chain or spec, return the hasher used */export function getSpecHasher ({ knownTypes }: Registry, chainName: Text | string, specName: Text | string): CodecHasher | null {  return withNames(chainName, specName, (c, s) =>    knownTypes.hasher ||    knownTypes.typesBundle?.chain?.[c]?.hasher ||    knownTypes.typesBundle?.spec?.[s]?.hasher ||    null  );}
/** * @description Based on the chain and runtimeVersion, get the applicable rpc definitions (ready for registration) */export function getSpecRpc ({ knownTypes }: Registry, chainName: Text | string, specName: Text | string): Record<string, Record<string, DefinitionRpc | DefinitionRpcSub>> {  return withNames(chainName, specName, (c, s) =>    objectSpread({},      knownTypes.typesBundle?.spec?.[s]?.rpc,      knownTypes.typesBundle?.chain?.[c]?.rpc    )  );}
/** * @description Based on the chain and runtimeVersion, get the applicable runtime definitions (ready for registration) */export function getSpecRuntime ({ knownTypes }: Registry, chainName: Text | string, specName: Text | string): DefinitionsCall {  return withNames(chainName, specName, (c, s) =>    objectSpread({},      knownTypes.typesBundle?.spec?.[s]?.runtime,      knownTypes.typesBundle?.chain?.[c]?.runtime    )  );}
/** * @description Based on the chain and runtimeVersion, get the applicable alias definitions (ready for registration) */export function getSpecAlias ({ knownTypes }: Registry, chainName: Text | string, specName: Text | string): Record<string, OverrideModuleType> {  return withNames(chainName, specName, (c, s) =>    // as per versions, first spec, then chain then finally non-versioned    objectSpread({},      knownTypes.typesBundle?.spec?.[s]?.alias,      knownTypes.typesBundle?.chain?.[c]?.alias,      knownTypes.typesAlias    )  );}
/** * @description Returns a version record for known chains where upgrades are being tracked */export function getUpgradeVersion (genesisHash: Hash, blockNumber: BN): [ChainUpgradeVersion | undefined, ChainUpgradeVersion | undefined] {  const known = upgrades.find((u) => genesisHash.eq(u.genesisHash));
  return known    ? [      known.versions.reduce<ChainUpgradeVersion | undefined>((last, version) => {        return blockNumber.gt(version.blockNumber)          ? version          : last;      }, undefined),      known.versions.find((version) => blockNumber.lte(version.blockNumber))    ]    : [undefined, undefined];}