Extend type generation (#1783)

* Cleanup type overrides

* Generate (with catch-all removal)

* Progress

* Re-gen tx types

* Remove unneeded option check

* Linting updates

* Update CHANGELOG (cleanups as per comments)
This commit is contained in:
Jaco Greeff
2020-01-31 15:34:06 +01:00
committed by GitHub
parent 982665c337
commit 4aa5693906
34 changed files with 1053 additions and 795 deletions
@@ -95,7 +95,7 @@ function hasWrapper (type: string, [start, end]: [string, string, TypeDefInfo, a
return false;
}
assert(type.endsWith(end), `Expected '${start}' closing with '${end}'`);
assert(type.endsWith(end), `Expected '${start}' closing with '${end}' on ${type}`);
return true;
}
@@ -14,41 +14,33 @@ import { createImportCode, createImports, FOOTER, HEADER, indent, setImports, Ty
// Generate types for one module
/** @internal */
function generateModule (allDefs: object, modul: ModuleMetadataLatest, imports: TypeImports): string[] {
if (!modul.constants.length) {
function generateModule (allDefs: object, { constants, name }: ModuleMetadataLatest, imports: TypeImports): string[] {
if (!constants.length) {
return [];
}
setImports(allDefs, imports, ['Codec']);
// NOTE Not removing this concat yet, first see the fallout (needs: setImports(allDefs, imports, ['Codec']);)
return [indent(4)(`${stringCamelCase(name.toString())}: {`)]
// .concat(indent(6)('[index: string]: Codec;'))
.concat(constants.map((constant): string => {
setImports(allDefs, imports, [constant.type.toString()]);
return [indent(4)(`${stringCamelCase(modul.name.toString())}: {`)]
.concat(indent(6)('[index: string]: Codec;'))
.concat(
modul.constants
.map((constant): string => {
setImports(allDefs, imports, [constant.type.toString()]);
return indent(6)(`${stringCamelCase(constant.name.toString())}: ${constant.type} & ConstantCodec;`);
})
)
return indent(6)(`${stringCamelCase(constant.name.toString())}: ${constant.type} & ConstantCodec;`);
}))
.concat([indent(4)('};')]);
}
// Generate `packages/api/src/consts.types.ts` for a particular
// metadata
/** @internal */
function generateForMeta (meta: Metadata, dest: string, extraTypes: Record<string, Record<string, object>>): void {
console.log(`Writing ${dest}`);
console.log(`${dest}\n\tGenerating`);
const allTypes: Record<string, Record<string, object>> = { '@polkadot/types/interfaces': defaultDefs, ...extraTypes };
const imports = createImports(allTypes);
const allDefs = Object.entries(allTypes).reduce((defs, [, obj]) => {
return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [key]: value }), defs);
}, {});
const body = meta.asLatest.modules.reduce((acc, modul): string[] => {
const storageEntries = generateModule(allDefs, modul, imports);
return acc.concat(storageEntries);
const body = meta.asLatest.modules.reduce((acc, mod): string[] => {
return acc.concat(generateModule(allDefs, mod, imports));
}, [] as string[]);
const header = createImportCode(HEADER, [
{
@@ -74,6 +66,8 @@ function generateForMeta (meta: Metadata, dest: string, extraTypes: Record<strin
].join('\n');
const interfaceEnd = `\n${indent(2)('}')}\n}`;
console.log('\tWriting');
fs.writeFileSync(
dest,
header
@@ -83,11 +77,13 @@ function generateForMeta (meta: Metadata, dest: string, extraTypes: Record<strin
.concat(FOOTER)
, { flag: 'w' }
);
console.log('');
}
// Call `generateForMeta()` with current static metadata
/** @internal */
export default function generateConsts (dest = 'packages/api/src/consts.types.ts', data = staticData, extraTypes: Record<string, Record<string, object>> = {}): void {
export default function generateConsts (dest = 'packages/api/src/types/augment/consts.ts', data = staticData, extraTypes: Record<string, Record<string, object>> = {}): void {
const registry = new TypeRegistry();
return generateForMeta(new Metadata(registry, data), dest, extraTypes);
@@ -7,14 +7,7 @@ import fs from 'fs';
import Raw from '../../codec/Raw';
import * as defaultDefinitions from '../../interfaces/definitions';
import * as defaultPrimitives from '../../primitive';
import {
createImportCode, createImports,
FOOTER,
getDerivedTypes,
HEADER,
indent,
setImports
} from '../util';
import { FOOTER, HEADER, createImportCode, createImports, getDerivedTypes, indent, setImports } from '../util';
const primitiveClasses = {
...defaultPrimitives,
@@ -23,7 +16,7 @@ const primitiveClasses = {
/** @internal */
export function generateInterfaceRegistry (importDefinitions: { [importPath: string]: object }, output: string): void {
console.log(`Writing ${output}`);
console.log(`${output}\n\tGenerating`);
Object.entries(importDefinitions).reduce((acc, def) => Object.assign(acc, def), {} as object);
@@ -72,11 +65,15 @@ export function generateInterfaceRegistry (importDefinitions: { [importPath: str
const interfaceStart = 'export interface InterfaceRegistry {';
const interfaceEnd = '\n}';
console.log('\tWriting');
fs.writeFileSync(
output,
header.concat(interfaceStart).concat(primitives).concat(srml).concat(interfaceEnd).concat(FOOTER)
, { flag: 'w' }
);
console.log('');
}
// Generate `packages/types/src/interfaceRegistry.ts`, the registry of all interfaces
@@ -12,7 +12,7 @@ import { stringLowerFirst } from '@polkadot/util';
import { Metadata } from '../..';
import { TypeRegistry } from '../../codec';
import { createImportCode, createImports, FOOTER, formatType, getSimilarTypes, HEADER, indent, setImports, TypeImports } from '../util';
import { FOOTER, HEADER, TypeImports, createImportCode, createImports, formatType, getSimilarTypes, indent, setImports } from '../util';
// If the StorageEntry returns T, output `Option<T>` if the modifier is optional
/** @internal */
@@ -73,34 +73,32 @@ function generateEntry (allDefs: object, registry: Registry, storageEntry: Stora
const [args, returnType] = entrySignature(allDefs, registry, storageEntry, imports);
return [
`${stringLowerFirst(storageEntry.name.toString())}: StorageEntryExact<ApiType, (${args}) => Observable<${returnType}>> & QueryableStorageEntry<ApiType>;`
`${stringLowerFirst(storageEntry.name.toString())}: AugmentedQuery<ApiType, (${args}) => Observable<${returnType}>> & QueryableStorageEntry<ApiType>;`
];
}
// Generate types for one module
/** @internal */
function generateModule (allDefs: object, registry: Registry, modul: ModuleMetadataLatest, imports: TypeImports): string[] {
if (modul.storage.isNone) {
function generateModule (allDefs: object, registry: Registry, { name, storage }: ModuleMetadataLatest, imports: TypeImports): string[] {
if (storage.isNone) {
return [];
}
return [indent(4)(`${stringLowerFirst(modul.name.toString())}: {`)]
.concat(indent(6)('[index: string]: QueryableStorageEntry<ApiType>;'))
.concat(
modul.storage.unwrap().items
.reduce((acc, storageEntry): string[] => {
return acc.concat(generateEntry(allDefs, registry, storageEntry, imports).map(indent(6)));
}, [] as string[])
.join('\n')
)
// NOTE Not removing this concat yet, first see the fallout
return [indent(4)(`${stringLowerFirst(name.toString())}: {`)]
// .concat(indent(6)('[index: string]: QueryableStorageEntry<ApiType>;'))
.concat(storage.unwrap()
.items
.reduce((acc, storageEntry): string[] => {
return acc.concat(generateEntry(allDefs, registry, storageEntry, imports).map(indent(6)));
}, [] as string[])
.join('\n'))
.concat([indent(4)('};')]);
}
// Generate `packages/api/src/query.types.ts` for a particular
// metadata
/** @internal */
function generateForMeta (registry: Registry, meta: Metadata, dest: string, extraTypes: Record<string, Record<string, object>>): void {
console.log(`Writing ${dest}`);
console.log(`${dest}\n\tGenerating`);
const allTypes: Record<string, Record<string, object>> = { '@polkadot/types/interfaces': defaultDefs, ...extraTypes };
const imports = createImports(allTypes);
@@ -108,9 +106,7 @@ function generateForMeta (registry: Registry, meta: Metadata, dest: string, extr
return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [key]: value }), defs);
}, {});
const body = meta.asLatest.modules.reduce((acc, mod): string[] => {
const storageEntries = generateModule(allDefs, registry, mod, imports);
return acc.concat(storageEntries);
return acc.concat(generateModule(allDefs, registry, mod, imports));
}, [] as string[]);
const header = createImportCode(HEADER, [
{
@@ -135,11 +131,13 @@ function generateForMeta (registry: Registry, meta: Metadata, dest: string, extr
}
]);
const interfaceStart = [
"declare module '@polkadot/api/types' {",
indent(2)('export interface QueryableStorageExact<ApiType> {\n')
"declare module '@polkadot/api/types/storage' {",
indent(2)('export interface AugmentedQueries<ApiType> {\n')
].join('\n');
const interfaceEnd = `\n${indent(2)('}')}\n}`;
console.log('\tWriting');
fs.writeFileSync(
dest,
header
@@ -149,11 +147,13 @@ function generateForMeta (registry: Registry, meta: Metadata, dest: string, extr
.concat(FOOTER)
, { flag: 'w' }
);
console.log('');
}
// Call `generateForMeta()` with current static metadata
/** @internal */
export default function generateQuery (dest = 'packages/api/src/query.types.ts', data = staticData, extraTypes: Record<string, Record<string, object>> = {}): void {
export default function generateQuery (dest = 'packages/api/src/types/augment/query.ts', data = staticData, extraTypes: Record<string, Record<string, object>> = {}): void {
const registry = new TypeRegistry();
return generateForMeta(registry, new Metadata(registry, data), dest, extraTypes);
@@ -9,10 +9,9 @@ import * as definitions from '../../interfaces/definitions';
import { TypeRegistry } from '../../codec/create';
import { createImportCode, createImports, FOOTER, getSimilarTypes, HEADER, setImports } from '../util';
// Generate `packages/rpc-core/jsonrpc.types.ts`
/** @internal */
export default function generateRpcTypes (dest = 'packages/rpc-core/src/jsonrpc.types.ts'): void {
console.log(`Writing ${dest}`);
console.log(`${dest}\n\tGenerating`);
const registry = new TypeRegistry();
const imports = createImports({ '@polkadot/types/interfaces': definitions });
@@ -77,9 +76,13 @@ export default function generateRpcTypes (dest = 'packages/rpc-core/src/jsonrpc.
const interfaceStart = 'export interface RpcInterface {\n';
const interfaceEnd = '\n}';
console.log('\tWriting');
fs.writeFileSync(
dest,
header.concat(interfaceStart).concat(body).concat(interfaceEnd).concat(FOOTER)
, { flag: 'w' }
);
console.log('');
}
@@ -194,32 +194,28 @@ function generateTsDefFor (importDefinitions: { [importPath: string]: object },
}))
]);
Object.entries(imports.localTypes).forEach(([moduleName, typeMap]): void => {
const types = Object.keys(typeMap).sort();
if (types.length) {
console.log(`\timport { ${types.join(', ')} } from '../${moduleName}'`);
}
});
fs.writeFileSync(path.join(outputDir, defName, 'types.ts'), header.concat(sortedDefs).concat(FOOTER), { flag: 'w' });
fs.writeFileSync(path.join(outputDir, defName, 'index.ts'), HEADER.concat('export * from \'./types\';').concat(FOOTER), { flag: 'w' });
}
/** @internal */
export function generateTsDef (importDefinitions: { [importPath: string]: object }, outputDir: string, generatingPackage: string): void {
console.log(`${outputDir}\n\tGenerating`);
const definitions = importDefinitions[generatingPackage];
Object.entries(definitions).forEach(([defName, obj]): void => {
console.log(`Extracting interfaces for ${defName}`);
console.log(`\tExtracting interfaces for ${defName}`);
generateTsDefFor(importDefinitions, defName, obj, outputDir);
});
console.log(`Writing ${outputDir}`);
console.log('\tWriting');
fs.writeFileSync(path.join(outputDir, 'types.ts'), HEADER.concat(Object.keys(definitions).map((moduleName): string => `export * from './${moduleName}/types';`).join('\n')).concat(FOOTER), { flag: 'w' });
fs.writeFileSync(path.join(outputDir, 'index.ts'), HEADER.concat('export * from \'./types\';').concat(FOOTER), { flag: 'w' });
console.log('');
}
/** @internal */
+122
View File
@@ -0,0 +1,122 @@
// Copyright 2017-2020 @polkadot/types authors & contributors
// This software may be modified and distributed under the terms
// of the Apache-2.0 license. See the LICENSE file for details.
import { ModuleMetadataLatest } from '../../interfaces/metadata';
import * as defaultDefs from '../../interfaces/definitions';
import { Registry } from '../../types';
import fs from 'fs';
import staticData from '@polkadot/metadata/Metadata/static';
import { Text } from '@polkadot/types';
import { stringCamelCase } from '@polkadot/util';
import { Metadata, TypeRegistry } from '../..';
import { FOOTER, HEADER, TypeImports, createImportCode, createImports, formatType, getSimilarTypes, indent, setImports } from '../util';
const MAPPED_NAMES: Record<string, string> = {
new: 'updated'
};
function mapName (_name: Text): string {
const name = stringCamelCase(_name.toString());
return MAPPED_NAMES[name] || name;
}
// Generate types for one module
/** @internal */
// eslint-disable-next-line @typescript-eslint/no-unused-vars
function generateModule (registry: Registry, allDefs: object, { calls, name }: ModuleMetadataLatest, imports: TypeImports): string[] {
const allCalls = calls.unwrapOr(null);
if (!allCalls?.length) {
return [];
}
setImports(allDefs, imports, ['CallFunction', 'SubmittableExtrinsic']);
// NOTE Not removing this concat yet, first see the fallout
return [indent(4)(`${stringCamelCase(name.toString())}: {`)]
// .concat(indent(6)('[index: string]: Codec;'))
.concat(allCalls.map(({ args, name }): string => {
const params = args.map(({ name, type }): string => {
const typeStr = type.toString();
const similarTypes = getSimilarTypes(allDefs, registry, typeStr, imports).map((type): string =>
type.startsWith('(')
? type
: formatType(allDefs, type, imports)
);
setImports(allDefs, imports, [...similarTypes.filter((type): boolean => !type.startsWith('(')), typeStr]);
return `${mapName(name)}: ${similarTypes.join(' | ')}`;
});
return indent(6)(`${stringCamelCase(name.toString())}: AugmentedSubmittable<ApiType, (${params.join(', ')}) => SubmittableExtrinsic<ApiType> & CallFunction>;`);
}))
.concat([indent(4)('};')]);
}
/** @internal */
function generateForMeta (registry: Registry, meta: Metadata, dest: string, extraTypes: Record<string, Record<string, object>>): void {
console.log(`${dest}\n\tGenerating`);
const allTypes: Record<string, Record<string, object>> = { '@polkadot/types/interfaces': defaultDefs, ...extraTypes };
const imports = createImports(allTypes);
const allDefs = Object.entries(allTypes).reduce((defs, [, obj]) => {
return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [key]: value }), defs);
}, {});
const body = meta.asLatest.modules.reduce((acc, mod): string[] => {
return acc.concat(generateModule(registry, allDefs, mod, imports));
}, [] as string[]);
const header = createImportCode(HEADER, [
{
file: '@polkadot/api/submittable/types',
types: ['SubmittableExtrinsic']
},
{
file: '@polkadot/types/codec',
types: Object.keys(imports.codecTypes).filter((name): boolean => name !== 'Tuple')
},
{
file: '@polkadot/types',
types: Object.keys(imports.primitiveTypes)
},
...Object.keys(imports.localTypes).map((moduleName): { file: string; types: string[] } => ({
file: `${imports.moduleToPackage[moduleName]}/${moduleName}`,
types: Object.keys(imports.localTypes[moduleName])
})),
{
file: '@polkadot/types/types',
types: Object.keys(imports.typesTypes)
}
]);
const interfaceStart = [
"declare module '@polkadot/api/types/submittable' {",
indent(2)('export interface AugmentedSubmittables<ApiType> {\n')
].join('\n');
const interfaceEnd = `\n${indent(2)('}')}\n}`;
console.log('\tWriting');
fs.writeFileSync(
dest,
header
.concat(interfaceStart)
.concat(body.join('\n'))
.concat(interfaceEnd)
.concat(FOOTER)
, { flag: 'w' }
);
console.log('');
}
// Call `generateForMeta()` with current static metadata
/** @internal */
export default function generateTx (dest = 'packages/api/src/types/augment/tx.ts', data = staticData, extraTypes: Record<string, Record<string, object>> = {}): void {
const registry = new TypeRegistry();
return generateForMeta(registry, new Metadata(registry, data), dest, extraTypes);
}
+13 -14
View File
@@ -2,19 +2,18 @@
// This software may be modified and distributed under the terms
// of the Apache-2.0 license. See the LICENSE file for details.
import generateConstsTypes from './generateTypes/consts';
import generateInterfaceRegistry from './generateTypes/interfaceRegistry';
import generateQueryTypes from './generateTypes/query';
import generateRpcTypes from './generateTypes/rpc';
import generateTsDef from './generateTypes/tsDef';
import generateConstsTypes from './generate/consts';
import generateInterfaceRegistry from './generate/interfaceRegistry';
import generateQueryTypes from './generate/query';
import generateRpcTypes from './generate/rpc';
import generateTsDef from './generate/tsDef';
import generateTxTypes from './generate/tx';
/** @internal */
function main (): void {
generateConstsTypes();
generateInterfaceRegistry();
generateQueryTypes();
generateRpcTypes();
generateTsDef();
}
generateInterfaceRegistry();
main();
generateConstsTypes();
generateQueryTypes();
generateTxTypes();
generateRpcTypes();
generateTsDef();
@@ -23,12 +23,13 @@ if (typeof WebSocket === 'undefined') {
const path = require('path');
const yargs = require('yargs');
const { formatNumber } = require('@polkadot/util');
const generateConst = require('./generateTypes/consts').default;
const generateQuery = require('./generateTypes/query').default;
const generateConst = require('./generate/consts').default;
const generateQuery = require('./generate/query').default;
const generateTx = require('./generate/tx').default;
const { endpoint, output, package } = yargs.strict().options({
endpoint: {
description: 'The endpoint to connect to, e.g. wss://kusama-rpc.polkadot.io',
description: 'The endpoint to connect to, e.g. wss://kusama-rpc.polkadot.io or relative file to JSON output',
type: 'string',
required: true
},
@@ -43,6 +44,20 @@ const { endpoint, output, package } = yargs.strict().options({
}).argv;
let websocket = null;
function generate (metaHex) {
console.log(`Generating from metadata, ${formatNumber((metaHex.length - 2) / 2)} bytes`);
const extraTypes = package
? { [package]: require(path.join(process.cwd(), output, 'definitions')) }
: {};
generateConst(path.join(process.cwd(), output, 'augment.consts.ts'), metaHex, extraTypes);
generateQuery(path.join(process.cwd(), output, 'augment.query.ts'), metaHex, extraTypes);
generateTx(path.join(process.cwd(), output, 'augment.tx.ts'), metaHex, extraTypes);
process.exit(0);
}
function onSocketClose (event) {
console.error(`${endpoint} disconnected, code: '${event.code}' reason: '${event.reason}'`);
@@ -64,22 +79,15 @@ function onSocketOpen () {
}
function onSocketMessage (message) {
const data = JSON.parse(message.data);
const metaHex = data.result;
const extraTypes = package
? { [package]: require(path.join(process.cwd(), output, 'definitions')) }
: {};
console.log(`Received metadata, ${formatNumber((metaHex.length - 2) / 2)} bytes`);
generateConst(path.join(process.cwd(), output, 'consts.types.ts'), metaHex, extraTypes);
generateQuery(path.join(process.cwd(), output, 'query.types.ts'), metaHex, extraTypes);
process.exit(0);
generate(JSON.parse(message.data).result);
}
websocket = new WebSocket(endpoint);
websocket.onclose = onSocketClose;
websocket.onerror = onSocketError;
websocket.onmessage = onSocketMessage;
websocket.onopen = onSocketOpen;
if (endpoint.startsWith('wss://') || endpoint.startsWith('ws://')) {
websocket = new WebSocket(endpoint);
websocket.onclose = onSocketClose;
websocket.onerror = onSocketError;
websocket.onmessage = onSocketMessage;
websocket.onopen = onSocketOpen;
} else {
generate(require(path.join(process.cwd(), endpoint)).result);
}
+33 -15
View File
@@ -8,6 +8,9 @@ import { Constructor, Registry } from '../../types';
import { isChildClass, isCompactEncodable } from './class';
import { ClassOfUnsafe, getTypeDef } from '../../codec/create';
import AbstractInt from '../../codec/AbstractInt';
import Compact from '../../codec/Compact';
import Option from '../../codec/Option';
import Struct from '../../codec/Struct';
import Vec from '../../codec/Vec';
import { formatType } from './formatting';
import { setImports, TypeImports } from './imports';
@@ -49,7 +52,7 @@ export function getDerivedTypes (definitions: object, type: string, primitiveNam
}
// Make types a little bit more flexible
// - if param instanceof AbstractInt, then param: u64 | Uint8array | string | number
// - if param instanceof AbstractInt, then param: u64 | Uint8array | AnyNumber
// etc
/** @internal */
export function getSimilarTypes (definitions: object, registry: Registry, type: string, imports: TypeImports): string[] {
@@ -58,24 +61,39 @@ export function getSimilarTypes (definitions: object, registry: Registry, type:
if (type === 'Extrinsic') {
setImports(definitions, imports, ['IExtrinsic']);
return ['IExtrinsic'];
} else if (type === 'StorageKey') {
// FIXME This is a hack, it's hard to correctly type StorageKeys in the
// current state
return ['StorageKey', 'any'];
}
if (isChildClass(Vec, ClassOfUnsafe(registry, type))) {
return [`(${getSimilarTypes(definitions, registry, ((getTypeDef(type).sub) as TypeDef).type, imports).join(' | ')})[]`];
const instance = ClassOfUnsafe(registry, type);
if (isChildClass(Vec, instance)) {
const subDef = (getTypeDef(type).sub) as TypeDef;
if (subDef.info === TypeDefInfo.Plain) {
possibleTypes.push(`(${getSimilarTypes(definitions, registry, subDef.type, imports).join(' | ')})[]`);
} else if (subDef.info === TypeDefInfo.Tuple) {
const subs = (subDef.sub as TypeDef[]).map(({ type }): string =>
getSimilarTypes(definitions, registry, type, imports).join(' | ')
);
possibleTypes.push(`([${subs.join(', ')}])[]`);
} else {
throw new Error(`Unhandled subtype in Vec, ${JSON.stringify(subDef)}`);
}
}
// FIXME This is a hack, it's hard to correctly type StorageKeys in the
// current state
if (type === 'StorageKey') {
return ['any'];
}
// Cannot get isChildClass of abstract class, but it works
if (isChildClass(AbstractInt as unknown as Constructor<any>, ClassOfUnsafe(registry, type))) {
possibleTypes.push('Uint8Array', 'number', 'string');
} else if (isChildClass(Uint8Array, ClassOfUnsafe(registry, type))) {
possibleTypes.push('Uint8Array', 'string');
} else if (isChildClass(String, ClassOfUnsafe(registry, type))) {
if (isChildClass(AbstractInt as unknown as Constructor<any>, instance) || isChildClass(Compact, instance)) {
possibleTypes.push('AnyNumber', 'Uint8Array');
} else if (isChildClass(Struct, instance)) {
possibleTypes.push('object', 'string', 'Uint8Array');
} else if (isChildClass(Option, instance)) {
possibleTypes.push('null', 'object', 'string', 'Uint8Array');
} else if (isChildClass(Uint8Array, instance)) {
possibleTypes.push('string', 'Uint8Array');
} else if (isChildClass(String, instance)) {
possibleTypes.push('string');
}
@@ -102,6 +102,7 @@ function formatVec (inner: string): string {
/** @internal */
export function formatType (definitions: object, type: string | TypeDef, imports: TypeImports): string {
let typeDef: TypeDef;
if (typeof type === 'string') {
typeDef = getTypeDef(type);
} else {
+1 -1
View File
@@ -35,7 +35,7 @@ export function setImports (allDefs: object, imports: TypeImports, types: string
types.forEach((type): void => {
if (ignoredTypes.includes(type)) {
// do nothing
} else if (['Codec', 'IExtrinsic', 'ITuple'].includes(type)) {
} else if (['AnyNumber', 'CallFunction', 'Codec', 'IExtrinsic', 'ITuple'].includes(type)) {
typesTypes[type] = true;
} else if ((codecClasses as any)[type]) {
codecTypes[type] = true;