@pezkuwi/types-known 16.5.5

package/src/upgrades/index.spec.ts

@@ -0,0 +1,118 @@
+// Copyright 2017-2025 @polkadot/types-known authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import type { ChainUpgradesExpanded, ChainUpgradesRaw } from './types.js';
+
+import { stringify, u8aEq } from '@pezkuwi/util';
+
+import * as allGen from './e2e/index.js';
+import * as allMan from './manual/index.js';
+import { upgrades } from './index.js';
+
+interface TestDef {
+  genesisHash: string;
+  network: string;
+  versions: [number, [number, number]][];
+}
+
+const TESTS: TestDef[] = [
+  {
+    genesisHash: '0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe',
+    network: 'kusama',
+    versions: [
+      [0, [0, 1020]],
+      [17, [901442, 1045]]
+    ]
+  },
+  {
+    genesisHash: '0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3',
+    network: 'polkadot',
+    versions: [
+      [0, [0, 0]],
+      [19, [2436698, 26]]
+    ]
+  },
+  {
+    genesisHash: '0xe143f23803ac50e8f6f8e62695d1ce9e4e1d68aa36c1cd2cfd15340213f3423e',
+    network: 'westend',
+    versions: [
+      [0, [214356, 4]],
+      [23, [4207800, 48]]
+    ]
+  }
+];
+
+function checkOrder (network: string, versions: [number, number, ...unknown[]][]): void {
+  const ooo = versions.filter((curr, index): boolean => {
+    const prev = versions[index - 1];
+
+    return index === 0
+      ? false
+      : curr[0] <= prev[0] || curr[1] <= prev[1];
+  });
+
+  if (ooo.length) {
+    throw new Error(`${network}: Mismatched upgrade ordering: ${stringify(ooo)}`);
+  }
+}
+
+describe('generated', (): void => {
+  it('should have all the chains', (): void => {
+    expect(Object.keys(allMan).sort()).toEqual(Object.keys(allGen).sort());
+  });
+
+  for (const chain of Object.keys(allMan)) {
+    describe(`${chain}`, (): void => {
+      // eslint-disable-next-line jest/expect-expect
+      it('should have all generated', (): void => {
+        const missing = allMan[chain as keyof typeof allMan].filter(([na, sa]) =>
+          !allGen[chain as keyof typeof allGen].some(([nb, sb]) =>
+            nb === na &&
+            sb === sa
+          )
+        );
+
+        if (missing.length !== 0) {
+          throw new Error(`${chain}:: missing generated apis found, run yarn test:one packages/types-known/src/upgrades/e2e`);
+        }
+      });
+
+      // eslint-disable-next-line jest/expect-expect
+      it('manual should be correctly ordered', (): void => {
+        checkOrder(chain, (allGen as Record<string, ChainUpgradesExpanded>)[chain]);
+      });
+
+      // eslint-disable-next-line jest/expect-expect
+      it('generated should be correctly ordered', (): void => {
+        checkOrder(chain, (allMan as Record<string, ChainUpgradesRaw>)[chain]);
+      });
+    });
+  }
+});
+
+describe('upgrades', (): void => {
+  TESTS.forEach(({ genesisHash, network, versions }): void => {
+    describe(`${network}`, (): void => {
+      const chain = upgrades.find((n) => n.network === network);
+
+      if (!chain) {
+        throw new Error(`Unable to find the entry for ${network}`);
+      }
+
+      it('has a valid genesisHash', (): void => {
+        expect(u8aEq(chain.genesisHash, genesisHash)).toBe(true);
+      });
+
+      versions.forEach(([index, [blockNumber, specVersion]]): void => {
+        it(`has a valid entry at index ${index}`, (): void => {
+          const version = chain.versions[index];
+
+          expect(version.blockNumber.eqn(blockNumber)).toBe(true);
+          expect(version.specVersion.eqn(specVersion)).toBe(true);
+        });
+      });
+    });
+  });
+});

package/src/upgrades/index.ts

@@ -0,0 +1,40 @@
+// Copyright 2017-2025 @polkadot/types-known authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ChainUpgrades } from '@pezkuwi/types/types';
+import type { HexString } from '@pezkuwi/util/types';
+import type { ChainUpgradesExpanded } from './types.js';
+
+import { selectableNetworks } from '@pezkuwi/networks';
+import { BN, hexToU8a } from '@pezkuwi/util';
+
+import * as allKnown from './e2e/index.js';
+
+// testnets are not available in the networks map
+const NET_EXTRA: Record<string, { genesisHash: HexString[] }> = {
+  westend: {
+    genesisHash: ['0xe143f23803ac50e8f6f8e62695d1ce9e4e1d68aa36c1cd2cfd15340213f3423e']
+  }
+};
+
+/** @internal */
+function mapRaw ([network, versions]: [string, ChainUpgradesExpanded]): ChainUpgrades {
+  const chain = selectableNetworks.find((n) => n.network === network) || NET_EXTRA[network];
+
+  if (!chain) {
+    throw new Error(`Unable to find info for chain ${network}`);
+  }
+
+  return {
+    genesisHash: hexToU8a(chain.genesisHash[0]),
+    network,
+    versions: versions.map(([blockNumber, specVersion, apis]) => ({
+      apis,
+      blockNumber: new BN(blockNumber),
+      specVersion: new BN(specVersion)
+    }))
+  };
+}
+
+// Type overrides for specific spec types & versions as given in runtimeVersion
+export const upgrades = Object.entries<ChainUpgradesExpanded>(allKnown).map(mapRaw);

package/src/upgrades/manual/index.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2025 @polkadot/types-known authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export { upgrades as kusama } from './kusama.js';
+export { upgrades as polkadot } from './polkadot.js';
+export { upgrades as westend } from './westend.js';

package/src/upgrades/manual/kusama.ts

@@ -0,0 +1,26 @@
+// Copyright 2017-2025 @polkadot/types-known authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ChainUpgradesRaw } from '../types.js';
+
+export const upgrades: ChainUpgradesRaw = [
+  [0, 1020], [26669, 1021], [38245, 1022], [54248, 1023], [59659, 1024],
+  [67651, 1025], [82191, 1027], [83238, 1028], [101503, 1029], [203466, 1030],
+  [295787, 1031], [461692, 1032], [504329, 1033], [569327, 1038], [587687, 1039],
+  [653183, 1040], [693488, 1042], [901442, 1045], [1375086, 1050], [1445458, 1051],
+  [1472960, 1052], [1475648, 1053], [1491596, 1054], [1574408, 1055], [2064961, 1058],
+  [2201991, 1062], [2671528, 2005], [2704202, 2007], [2728002, 2008], [2832534, 2011],
+  [2962294, 2012], [3240000, 2013], [3274408, 2015], [3323565, 2019], [3534175, 2022],
+  [3860281, 2023], [4143129, 2024], [4401242, 2025], [4841367, 2026], [5961600, 2027],
+  [6137912, 2028], [6561855, 2029], [7100891, 2030], [7468792, 9010], [7668600, 9030],
+  [7812476, 9040], [8010981, 9050], [8073833, 9070], [8555825, 9080], [8945245, 9090],
+  [9611377, 9100], [9625129, 9111], [9866422, 9122], [10403784, 9130], [10960765, 9150],
+  [11006614, 9151], [11404482, 9160], [11601803, 9170], [12008022, 9180], [12405451, 9190],
+  [12665416, 9200], [12909508, 9220], [13109752, 9230], [13555777, 9250], [13727747, 9260],
+  [14248044, 9271], [14433840, 9280], [14645900, 9291], [15048375, 9300], [15426015, 9320],
+  // we have 9340 via system.setStorage (whitelist.WhitelistedCallDispatched event)
+  [15680713, 9340], [15756296, 9350], [15912007, 9360], [16356547, 9370], [17335450, 9381],
+  [18062739, 9420], [18625000, 9430], [20465806, 1000000], [21570000, 1001000], [21786291, 1001002],
+  [22515962, 1001003], [22790000, 1002000], [23176015, 1002001], [23450253, 1002004], [23565293, 1002005],
+  [23780224, 1002006], [24786390, 1003000]
+];

package/src/upgrades/manual/polkadot.ts

@@ -0,0 +1,19 @@
+// Copyright 2017-2025 @polkadot/types-known authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ChainUpgradesRaw } from '../types.js';
+
+export const upgrades: ChainUpgradesRaw = [
+  [0, 0], [29231, 1], [188836, 5], [199405, 6], [214264, 7],
+  [244358, 8], [303079, 9], [314201, 10], [342400, 11], [443963, 12],
+  [528470, 13], [687751, 14], [746085, 15], [787923, 16], [799302, 17],
+  [1205128, 18], [1603423, 23], [1733218, 24], [2005673, 25], [2436698, 26],
+  [3613564, 27], [3899547, 28], [4345767, 29], [4876134, 30], [5661442, 9050],
+  [6321619, 9080], [6713249, 9090], [7217907, 9100], [7229126, 9110], [7560558, 9122],
+  [8115869, 9140], [8638103, 9151], [9280179, 9170], [9738717, 9180], [10156856, 9190],
+  [10458576, 9200], [10655116, 9220], [10879371, 9230], [11328884, 9250], [11532856, 9260],
+  [11933818, 9270], [12217535, 9280], [12245277, 9281], [12532644, 9291], [12876189, 9300],
+  [13800015, 9340], [14188833, 9360], [14543918, 9370], [15978362, 9420], [16450000, 9430],
+  [17840000, 9431], [18407475, 1000001], [19551000, 1001002], [20181758, 1001003],
+  [20438530, 1002000], [21169168, 1002004], [21455374, 1002005], [21558004, 1002006], [21800141, 1002007]
+];

package/src/upgrades/manual/westend.ts

@@ -0,0 +1,27 @@
+// Copyright 2017-2025 @polkadot/types-known authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ChainUpgradesRaw } from '../types.js';
+
+export const upgrades: ChainUpgradesRaw = [
+  [214356, 4], [392764, 7], [409740, 8], [809976, 20], [877581, 24],
+  [879238, 25], [889472, 26], [902937, 27], [932751, 28], [991142, 29],
+  [1030162, 31], [1119657, 32], [1199282, 33], [1342534, 34], [1392263, 35],
+  [1431703, 36], [1433369, 37], [1490972, 41], [2087397, 43], [2316688, 44],
+  [2549864, 45], [3925782, 46], [3925843, 47], [4207800, 48], [4627944, 49],
+  [5124076, 50], [5478664, 900], [5482450, 9000], [5584305, 9010], [5784566, 9030],
+  [5879822, 9031], [5896856, 9032], [5897316, 9033], [6117927, 9050], [6210274, 9070],
+  [6379314, 9080], [6979141, 9090], [7568453, 9100], [7766394, 9111], [7911691, 9120],
+  [7968866, 9121], [7982889, 9122], [8514322, 9130], [9091726, 9140], [9091774, 9150],
+  [9406726, 9160], [9921066, 9170], [10007115, 9180], [10480973, 9190], [10578091, 9200],
+  [10678509, 9210], [10811001, 9220], [11096116, 9230], [11409279, 9250], [11584820, 9251],
+  [11716837, 9260], [11876919, 9261], [11987927, 9270], [12077324, 9271], [12301871, 9280],
+  [12604343, 9290], [12841034, 9300], [13128237, 9310], [13272363, 9320], [13483497, 9330],
+  [13649433, 9340], [13761100, 9350], [13847400, 9360], [14249200, 9370], [14576855, 9380],
+  [14849830, 9390], [15146832, 9400], [15332317, 9401], [15661793, 9420], [16165469, 9430],
+  [18293984, 102000], [18293991, 103000], [18451783, 104000], [18679741, 1005000], [19166695, 1006000],
+  [19234157, 1006001], [19542944, 1007000], [19621258, 1007001], [19761406, 1008000], [20056997, 1009000],
+  [20368318, 1010000], [20649086, 1011000], [21217837, 1011001], [21300429, 1013000], [21460051, 1014000],
+  [21925427, 1015000], [22500517, 1016000], [22759684, 1016001], [23056976, 1016002], [23544582, 1017000],
+  [24002343, 1017001]
+];

package/src/upgrades/types.ts

@@ -0,0 +1,8 @@
+// Copyright 2017-2025 @polkadot/types-known authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { HexString } from '@pezkuwi/util/types';
+
+export type ChainUpgradesRaw = [blockNumber: number, specVersion: number][];
+
+export type ChainUpgradesExpanded = [blockNumber: number, specVersion: number, runtimeApis: [apiHash: HexString, apiVersion: number][]][];

package/src/util.ts

@@ -0,0 +1,128 @@
+// Copyright 2017-2025 @polkadot/types-known authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ExtDef } from '@pezkuwi/types/extrinsic/signedExtensions/types';
+import type { Hash } from '@pezkuwi/types/interfaces';
+import type { ChainUpgradeVersion, CodecHasher, DefinitionRpc, DefinitionRpcSub, DefinitionsCall, OverrideModuleType, OverrideVersionedType, Registry, RegistryTypes } from '@pezkuwi/types/types';
+import type { Text } from '@pezkuwi/types-codec';
+import type { BN } from '@pezkuwi/util';
+
+import { bnToBn } from '@pezkuwi/util';
+
+import { typesChain } from './chain/index.js';
+import { typesSpec } from './spec/index.js';
+import { upgrades } from './upgrades/index.js';
+
+/**
+ * @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 }) => ({ ...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) => ({
+    ...(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
+    ...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) => ({
+    ...(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) => ({
+    ...(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
+    ...(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];
+}

package/tsconfig.build.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": "..",
+    "outDir": "./build",
+    "rootDir": "./src"
+  },
+  "exclude": [
+    "**/*.spec.ts",
+    "**/mod.ts"
+  ],
+  "references": [
+    { "path": "../types/tsconfig.build.json" },
+    { "path": "../types-codec/tsconfig.build.json" },
+    { "path": "../types-create/tsconfig.build.json" }
+  ]
+}