@dedot/codegen 0.0.1-next.8beb88c3.11 → 0.0.1-next.8f4b2c24.6

package/generator/JsonRpcGen.js

@@ -0,0 +1,55 @@
+import { ApiGen } from '../generator/index.js';
+import { beautifySourceCode, compileTemplate } from './utils.js';
+import { subscriptionsInfo } from '@dedot/specs';
+const HIDDEN_RPCS = [
+    // Ref: https://github.com/paritytech/polkadot-sdk/blob/43415ef58c143b985e09015cd000dbd65f6d3997/substrate/client/rpc-servers/src/lib.rs#L152C9-L158
+    'rpc_methods',
+];
+const ALIAS_RPCS = [
+    // TODO include these into the specs
+    'account_nextIndex',
+    'system_dryRunAt',
+    'state_callAt',
+    'state_getKeysPagedAt',
+    'state_getStorageAt',
+    'state_getStorageHashAt',
+    'state_getStorageSizeAt',
+    'chain_getRuntimeVersion',
+    'chain_getHead',
+    'chain_getFinalisedHead',
+    'childstate_getKeysPagedAt',
+    // Subscription pairs
+    'chain_subscribeRuntimeVersion',
+    'chain_unsubscribeRuntimeVersion',
+    'chain_unsubscribeNewHead',
+    'chain_subscribeNewHead',
+    'subscribe_newHead',
+    'unsubscribe_newHead',
+    'chain_subscribeFinalisedHeads',
+    'chain_unsubscribeFinalisedHeads',
+];
+export class JsonRpcGen extends ApiGen {
+    typesGen;
+    rpcMethods;
+    constructor(typesGen, rpcMethods) {
+        super(typesGen);
+        this.typesGen = typesGen;
+        this.rpcMethods = rpcMethods;
+        HIDDEN_RPCS.filter((one) => !rpcMethods.includes(one)).forEach((one) => rpcMethods.push(one));
+        rpcMethods.sort();
+    }
+    generate() {
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericJsonRpcApis');
+        this.typesGen.typeImports.addSpecType('JsonRpcApis');
+        const toExclude = Object.values(subscriptionsInfo).flat();
+        const importTypes = this.typesGen.typeImports.toImports();
+        const template = compileTemplate('json-rpc.hbs');
+        const jsonRpcMethods = this.rpcMethods
+            .filter((one) => !ALIAS_RPCS.includes(one)) // exclude alias rpcs
+            .filter((one) => !toExclude.includes(one)) // exclude unsubscribe methods
+            .map((one) => `'${one}'`)
+            .join(' | ');
+        return beautifySourceCode(template({ importTypes, jsonRpcMethods }));
+    }
+}

package/generator/QueryGen.d.ts

@@ -1,4 +1,4 @@
-import { ApiGen } from '../generator';
+import { ApiGen } from './ApiGen.js';
 export declare class QueryGen extends ApiGen {
     #private;
     generate(): Promise<string>;

package/generator/QueryGen.js

@@ -1,7 +1,6 @@
-import { stringLowerFirst } from '@polkadot/util';
-import { normalizeName } from '@dedot/utils';
-import { ApiGen } from '../generator';
-import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
+import { normalizeName, stringCamelCase } from '@dedot/utils';
+import { ApiGen } from './ApiGen.js';
+import { beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
 export class QueryGen extends ApiGen {
     generate() {
         const { pallets } = this.metadata;
@@ -13,9 +12,16 @@ export class QueryGen extends ApiGen {
             if (!storage)
                 continue;
             const queries = storage.entries.map((one) => this.#generateEntry(one));
-            const queryDefs = queries.map(({ name, valueType, keyType, docs }) => `${commentBlock(docs)}${name}: GenericStorageQuery<(${keyType}) => ${valueType}>`);
+            const queryDefs = queries.map(({ name, valueType, keyType, docs, keyTypeOut }) => {
+                if (keyTypeOut) {
+                    return `${commentBlock(docs)}${name}: GenericStorageQuery<(${keyType}) => ${valueType}, ${keyTypeOut}>`;
+                }
+                else {
+                    return `${commentBlock(docs)}${name}: GenericStorageQuery<(${keyType}) => ${valueType}>`;
+                }
+            });
             defTypeOut += commentBlock(`Pallet \`${pallet.name}\`'s storage queries`);
-            defTypeOut += `${stringLowerFirst(pallet.name)}: {
+            defTypeOut += `${stringCamelCase(pallet.name)}: {
         ${queryDefs.join(',\n')}
         
         ${commentBlock('Generic pallet storage query')}[storage: string]: GenericStorageQuery;
@@ -27,13 +33,14 @@ export class QueryGen extends ApiGen {
     }
     #generateEntry(entry) {
         const { name, type, docs, modifier } = entry;
-        let valueType, keyType;
+        let valueType, keyTypeOut, keyTypeIn;
         if (type.tag === 'Plain') {
             valueType = this.typesGen.generateType(type.value.valueTypeId, 1, true);
         }
         else if (type.tag === 'Map') {
             valueType = this.typesGen.generateType(type.value.valueTypeId, 1, true);
-            keyType = this.typesGen.generateType(type.value.keyTypeId, 1);
+            keyTypeOut = this.typesGen.generateType(type.value.keyTypeId, 1, true);
+            keyTypeIn = this.typesGen.generateType(type.value.keyTypeId, 1);
         }
         else {
             throw Error('Invalid entry type!');
@@ -41,14 +48,15 @@ export class QueryGen extends ApiGen {
         const isOptional = modifier === 'Optional';
         valueType = `${valueType}${isOptional ? ' | undefined' : ''}`;
         docs.push('\n');
-        if (keyType) {
-            docs.push(`@param {${keyType}} arg`);
+        if (keyTypeIn) {
+            docs.push(`@param {${keyTypeIn}} arg`);
         }
         docs.push(`@param {Callback<${valueType}> =} callback`);
         return {
             name: normalizeName(name),
             valueType,
-            keyType: keyType ? `arg: ${keyType}` : '',
+            keyType: keyTypeIn ? `arg: ${keyTypeIn}` : '',
+            keyTypeOut,
             docs,
         };
     }

package/generator/RuntimeApisGen.d.ts

@@ -1,9 +1,9 @@
-import { TypesGen } from './TypesGen';
-import { RpcGen } from './RpcGen';
-export declare class RuntimeApisGen extends RpcGen {
+import { TypesGen } from './TypesGen.js';
+import { ApiGen } from './ApiGen.js';
+export declare class RuntimeApisGen extends ApiGen {
     #private;
     readonly typesGen: TypesGen;
-    readonly runtimeApis: [string, number][];
-    constructor(typesGen: TypesGen, runtimeApis: [string, number][]);
+    readonly runtimeApis: Record<string, number>;
+    constructor(typesGen: TypesGen, runtimeApis: Record<string, number>);
     generate(): Promise<string>;
 }

package/generator/RuntimeApisGen.js

@@ -1,13 +1,13 @@
-import { findRuntimeApiSpec } from '@dedot/specs';
-import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
-import { calculateRuntimeApiHash, stringSnakeCase } from '@dedot/utils';
-import { RpcGen } from './RpcGen';
-import { stringCamelCase } from '@polkadot/util';
-export class RuntimeApisGen extends RpcGen {
+import { getRuntimeApiNames, getRuntimeApiSpecs } from '@dedot/specs';
+import { beautifySourceCode, commentBlock, compileTemplate, isNativeType, TUPLE_TYPE_REGEX, WRAPPER_TYPE_REGEX, } from './utils.js';
+import { calcRuntimeApiHash, stringSnakeCase, stringCamelCase } from '@dedot/utils';
+import { ApiGen } from './ApiGen.js';
+import { findKnownCodecType } from './known-codecs.js';
+export class RuntimeApisGen extends ApiGen {
     typesGen;
     runtimeApis;
     constructor(typesGen, runtimeApis) {
-        super(typesGen, []);
+        super(typesGen);
         this.typesGen = typesGen;
         this.runtimeApis = runtimeApis;
     }
@@ -18,7 +18,7 @@ export class RuntimeApisGen extends RpcGen {
         if (this.metadata.apis.length > 0) {
             this.metadata.apis.forEach((runtimeApi) => {
                 const { name: runtimeApiName, methods } = runtimeApi;
-                runtimeCallsOut += commentBlock(`@runtimeapi: ${runtimeApiName} - ${calculateRuntimeApiHash(runtimeApiName)}`);
+                runtimeCallsOut += commentBlock(`@runtimeapi: ${runtimeApiName} - ${calcRuntimeApiHash(runtimeApiName)}`);
                 runtimeCallsOut += `${stringCamelCase(runtimeApiName)}: {
             ${methods.map((method) => this.#generateMethodDef(runtimeApiName, method)).join('\n')} 
               
@@ -57,17 +57,17 @@ export class RuntimeApisGen extends RpcGen {
         const { docs = [], params, type, runtimeApiName, methodName } = spec;
         const callName = `${runtimeApiName}_${stringSnakeCase(methodName)}`;
         const defaultDocs = [`@callname: ${callName}`];
-        this.addTypeImport(type, false);
-        params.forEach(({ type }) => this.addTypeImport(type));
+        this.#addTypeImport(type, false);
+        params.forEach(({ type }) => this.#addTypeImport(type));
         const typedParams = params.map((param, idx) => ({
             ...param,
             isOptional: this.#isOptionalParam(params, param.type, idx),
-            plainType: this.getGeneratedTypeName(param.type),
+            plainType: this.#getGeneratedTypeName(param.type),
         }));
         const paramsOut = typedParams
             .map(({ name, isOptional, plainType }) => `${stringCamelCase(name)}${isOptional ? '?' : ''}: ${plainType}`)
             .join(', ');
-        const typeOut = this.getGeneratedTypeName(type, false);
+        const typeOut = this.#getGeneratedTypeName(type, false);
         return `${commentBlock(docs, '\n', defaultDocs, typedParams.map(({ plainType, name }) => `@param {${plainType}} ${name}`))}${methodName}: GenericRuntimeApiMethod<(${paramsOut}) => Promise<${typeOut}>>`;
     }
     #generateMethodDef(runtimeApiName, methodDef) {
@@ -75,7 +75,7 @@ export class RuntimeApisGen extends RpcGen {
         const callName = `${runtimeApiName}_${stringSnakeCase(methodName)}`;
         const defaultDocs = [`@callname: ${callName}`];
         const typeOut = this.typesGen.generateType(output, 1, true);
-        this.addTypeImport(typeOut, false);
+        this.#addTypeImport(typeOut, false);
         const typedInputs = inputs
             .map((input, idx) => ({
             ...input,
@@ -85,15 +85,15 @@ export class RuntimeApisGen extends RpcGen {
             ...input,
             isOptional: this.#isOptionalParam(inputs, input.type, idx),
         }));
-        this.addTypeImport(typedInputs.map((t) => t.type));
+        this.#addTypeImport(typedInputs.map((t) => t.type));
         const paramsOut = typedInputs
             .map(({ name, type, isOptional }) => `${stringCamelCase(name)}${isOptional ? '?' : ''}: ${type}`)
             .join(', ');
         return `${commentBlock(docs, '\n', defaultDocs, typedInputs.map(({ type, name }) => `@param {${type}} ${name}`))}${stringCamelCase(methodName)}: GenericRuntimeApiMethod<(${paramsOut}) => Promise<${typeOut}>>`;
     }
     #targetRuntimeApiSpecs() {
-        const specs = this.runtimeApis.map(([runtimeApiHash, version]) => {
-            const runtimeApiSpec = findRuntimeApiSpec(runtimeApiHash, version);
+        const specs = Object.entries(this.runtimeApis).map(([runtimeApiHash, version]) => {
+            const runtimeApiSpec = this.#findRuntimeApiSpec(runtimeApiHash, version);
             if (!runtimeApiSpec)
                 return;
             return {
@@ -108,4 +108,82 @@ export class RuntimeApisGen extends RpcGen {
             return [...o, spec];
         }, []);
     }
+    #findRuntimeApiSpec = (runtimeApiHash, version) => {
+        const runtimeApiName = getRuntimeApiNames().find((one) => calcRuntimeApiHash(one) === runtimeApiHash);
+        return getRuntimeApiSpecs().find((one) => one.runtimeApiName === runtimeApiName && one.version === version);
+    };
+    // TODO check typeIn, typeOut if param type, or rpc type isScale
+    #addTypeImport(type, toTypeIn = true) {
+        if (Array.isArray(type)) {
+            type.forEach((one) => this.#addTypeImport(one, toTypeIn));
+            return;
+        }
+        type = type.trim();
+        if (isNativeType(type)) {
+            return;
+        }
+        // Handle generic wrapper types
+        const matchArray = type.match(WRAPPER_TYPE_REGEX);
+        if (matchArray) {
+            const [_, $1, $2] = matchArray;
+            this.#addTypeImport($1, toTypeIn);
+            if ($2.match(WRAPPER_TYPE_REGEX) || $2.match(TUPLE_TYPE_REGEX)) {
+                this.#addTypeImport($2, toTypeIn);
+            }
+            else {
+                this.#addTypeImport($2.split(','), toTypeIn);
+            }
+            return;
+        }
+        // Check tuple type
+        if (type.match(TUPLE_TYPE_REGEX)) {
+            this.#addTypeImport(type.slice(1, -1).split(','), toTypeIn);
+            return;
+        }
+        if (type.includes(' | ')) {
+            this.#addTypeImport(type.split(' | ').map((one) => one.trim()), toTypeIn);
+            return;
+        }
+        try {
+            const codecType = this.#getCodecType(type, toTypeIn);
+            if (isNativeType(codecType))
+                return;
+            this.typesGen.typeImports.addCodecType(codecType);
+            return;
+        }
+        catch (e) { }
+        this.typesGen.addTypeImport(type);
+    }
+    #getGeneratedTypeName(type, toTypeIn = true) {
+        try {
+            const matchArray = type.match(WRAPPER_TYPE_REGEX);
+            if (matchArray) {
+                const [_, $1, $2] = matchArray;
+                const wrapperTypeName = this.#getCodecType($1, toTypeIn);
+                if ($2.match(WRAPPER_TYPE_REGEX) || $2.match(TUPLE_TYPE_REGEX)) {
+                    return `${wrapperTypeName}<${this.#getGeneratedTypeName($2, toTypeIn)}>`;
+                }
+                const innerTypeNames = $2
+                    .split(',')
+                    .map((one) => this.#getGeneratedTypeName(one.trim(), toTypeIn))
+                    .join(', ');
+                return `${wrapperTypeName}<${innerTypeNames}>`;
+            }
+            else if (type.match(TUPLE_TYPE_REGEX)) {
+                const innerTypeNames = type
+                    .slice(1, -1)
+                    .split(',')
+                    .map((one) => this.#getGeneratedTypeName(one.trim(), toTypeIn))
+                    .join(', ');
+                return `[${innerTypeNames}]`;
+            }
+            return this.#getCodecType(type, toTypeIn);
+        }
+        catch (e) { }
+        return type;
+    }
+    #getCodecType(type, toTypeIn = true) {
+        const { typeIn, typeOut } = findKnownCodecType(type);
+        return toTypeIn ? typeIn : typeOut;
+    }
 }

package/generator/TxGen.d.ts

@@ -1,4 +1,4 @@
-import { ApiGen } from '../generator';
+import { ApiGen } from '../generator/index.js';
 export declare class TxGen extends ApiGen {
     #private;
     generate(): Promise<string>;

package/generator/TxGen.js

@@ -1,6 +1,6 @@
-import { ApiGen } from '../generator';
-import { stringCamelCase, stringPascalCase } from '@polkadot/util';
-import { beautifySourceCode, commentBlock, compileTemplate, isReservedWord } from './utils';
+import { ApiGen } from '../generator/index.js';
+import { stringCamelCase, stringPascalCase } from '@dedot/utils';
+import { beautifySourceCode, commentBlock, compileTemplate, isReservedWord } from './utils.js';
 export class TxGen extends ApiGen {
     generate() {
         const { pallets, types } = this.metadata;

package/generator/TypeImports.d.ts

@@ -3,6 +3,7 @@ export declare class TypeImports {
     portableTypes: Set<string>;
     codecTypes: Set<string>;
     knownTypes: Set<string>;
+    specTypes: Set<string>;
     outTypes: Set<string>;
     constructor();
     clear(): void;
@@ -10,5 +11,6 @@ export declare class TypeImports {
     addPortableType(...types: string[]): void;
     addCodecType(...types: string[]): void;
     addKnownType(...types: string[]): void;
+    addSpecType(...types: string[]): void;
     addOutType(...types: string[]): void;
 }

package/generator/TypeImports.js

@@ -5,30 +5,35 @@ export class TypeImports {
     codecTypes;
     // Known types that're not codecs or chain/portable types defined in @dedot/types
     knownTypes;
+    specTypes;
     // External types to define explicitly
     outTypes;
     constructor() {
         this.portableTypes = new Set();
         this.codecTypes = new Set();
         this.knownTypes = new Set();
+        this.specTypes = new Set();
         this.outTypes = new Set();
     }
     clear() {
         this.portableTypes.clear();
         this.codecTypes.clear();
         this.knownTypes.clear();
+        this.specTypes.clear();
         this.outTypes.clear();
     }
     toImports(...excludeModules) {
         // TODO generate outTypes!
         const toImports = [
             [this.knownTypes, '@dedot/types'],
+            [this.specTypes, '@dedot/specs'],
             [this.codecTypes, '@dedot/codecs'],
             [this.portableTypes, './types'],
         ];
         return toImports
             .filter(([_, module]) => !excludeModules.includes(module))
             .map(([types, module]) => this.#toImportLine(types, module))
+            .filter((line) => line.length > 0)
             .join('\n');
     }
     #toImportLine(types, module) {
@@ -46,6 +51,9 @@ export class TypeImports {
     addKnownType(...types) {
         types.forEach((one) => this.knownTypes.add(one));
     }
+    addSpecType(...types) {
+        types.forEach((one) => this.specTypes.add(one));
+    }
     addOutType(...types) {
         types.forEach((one) => this.outTypes.add(one));
     }

package/generator/TypesGen.d.ts

@@ -1,5 +1,5 @@
-import { CodecRegistry, Field, MetadataLatest, PortableType, TypeId } from '@dedot/codecs';
-import { TypeImports } from './TypeImports';
+import { Field, MetadataLatest, PortableRegistry, PortableType, TypeId } from '@dedot/codecs';
+import { TypeImports } from './TypeImports.js';
 interface NamedType extends PortableType {
     name: string;
     nameOut: string;
@@ -15,7 +15,7 @@ export declare class TypesGen {
      * Types will be generated its definition out.
      */
     includedTypes: Record<TypeId, NamedType>;
-    registry: CodecRegistry;
+    registry: PortableRegistry;
     typeImports: TypeImports;
     constructor(metadata: MetadataLatest);
     generate(): Promise<string>;

package/generator/TypesGen.js

@@ -1,9 +1,8 @@
-import { stringPascalCase } from '@polkadot/util';
-import { CodecRegistry } from '@dedot/codecs';
-import { isNativeType, normalizeName } from '@dedot/utils';
-import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
-import { registry } from '@dedot/types';
-import { TypeImports } from './TypeImports';
+import { PortableRegistry } from '@dedot/codecs';
+import { normalizeName, stringPascalCase } from '@dedot/utils';
+import { beautifySourceCode, commentBlock, compileTemplate, isNativeType } from './utils.js';
+import { TypeImports } from './TypeImports.js';
+import { findKnownCodec, findKnownCodecType, isKnownCodecType } from './known-codecs.js';
 // Skip generate types for these
 // as we do have native types for them
 const SKIP_TYPES = [
@@ -37,7 +36,7 @@ export class TypesGen {
     typeImports;
     constructor(metadata) {
         this.metadata = metadata;
-        this.registry = new CodecRegistry(this.metadata);
+        this.registry = new PortableRegistry(this.metadata);
         this.includedTypes = this.#includedTypes();
         this.typeImports = new TypeImports();
     }
@@ -99,7 +98,7 @@ export class TypesGen {
         const { tag, value } = type;
         switch (tag) {
             case 'Primitive':
-                const $codec = this.registry.findCodec(value.kind);
+                const $codec = findKnownCodec(value.kind);
                 if ($codec.nativeType) {
                     return $codec.nativeType;
                 }
@@ -168,7 +167,7 @@ export class TypesGen {
                             membersType.push([keyName, this.generateObjectType(fields, nestedLevel + 1, typeOut), docs]);
                         }
                     }
-                    const { tagKey, valueKey } = this.registry.portableRegistry.getEnumOptions(typeId);
+                    const { tagKey, valueKey } = this.registry.getEnumOptions(typeId);
                     return membersType
                         .map(([keyName, valueType, docs]) => ({
                         tag: `${tagKey}: '${keyName}'`,
@@ -263,8 +262,8 @@ export class TypesGen {
             const suffix = typeSuffixes.get(id) || '';
             let knownType = false;
             let name, nameOut;
-            if (this.registry.isKnownType(joinedPath)) {
-                const codecType = this.registry.findCodecType(path.at(-1));
+            if (isKnownCodecType(joinedPath)) {
+                const codecType = findKnownCodecType(path.at(-1));
                 name = codecType.typeIn;
                 nameOut = codecType.typeOut;
                 knownType = true;
@@ -317,7 +316,7 @@ export class TypesGen {
     }
     #shouldGenerateTypeIn(id) {
         const { callTypeId } = this.metadata.extrinsic;
-        const palletCallTypeIds = this.registry.portableRegistry.getPalletCallTypeIds();
+        const palletCallTypeIds = this.registry.getPalletCallTypeIds();
         return callTypeId === id || palletCallTypeIds.includes(id);
     }
     eqlCache = new Map();
@@ -422,11 +421,6 @@ export class TypesGen {
             this.typeImports.addCodecType(typeName);
             return;
         }
-        if (registry.has(typeName)) {
-            this.typeImports.addKnownType(typeName);
-        }
-        else {
-            this.typeImports.addOutType(typeName);
-        }
+        this.typeImports.addOutType(typeName);
     }
 }

package/generator/index.d.ts

@@ -1,10 +1,10 @@
-export * from './TypesGen';
-export * from './ApiGen';
-export * from './ConstsGen';
-export * from './QueryGen';
-export * from './RpcGen';
-export * from './IndexGen';
-export * from './ErrorsGen';
-export * from './EventsGen';
-export * from './TxGen';
-export * from './RuntimeApisGen';
+export * from './TypesGen.js';
+export * from './ApiGen.js';
+export * from './ConstsGen.js';
+export * from './QueryGen.js';
+export * from './JsonRpcGen.js';
+export * from './IndexGen.js';
+export * from './ErrorsGen.js';
+export * from './EventsGen.js';
+export * from './TxGen.js';
+export * from './RuntimeApisGen.js';

package/generator/index.js

@@ -1,10 +1,10 @@
-export * from './TypesGen';
-export * from './ApiGen';
-export * from './ConstsGen';
-export * from './QueryGen';
-export * from './RpcGen';
-export * from './IndexGen';
-export * from './ErrorsGen';
-export * from './EventsGen';
-export * from './TxGen';
-export * from './RuntimeApisGen';
+export * from './TypesGen.js';
+export * from './ApiGen.js';
+export * from './ConstsGen.js';
+export * from './QueryGen.js';
+export * from './JsonRpcGen.js';
+export * from './IndexGen.js';
+export * from './ErrorsGen.js';
+export * from './EventsGen.js';
+export * from './TxGen.js';
+export * from './RuntimeApisGen.js';

package/generator/known-codecs.d.ts

@@ -0,0 +1,23 @@
+import * as $ from '@dedot/shape';
+import { AnyShape } from '@dedot/shape';
+export type CodecName = `$${string}`;
+export interface CodecType {
+    name: CodecName;
+    $codec: AnyShape;
+    typeIn: string;
+    typeOut: string;
+}
+export declare const normalizeCodecName: (name: string | CodecName) => CodecName;
+/**
+ * Collection of codec types with loose input types
+ *
+ * Loose codecs are codecs with different typeIn & typeOut,
+ * E.g: Codec `$AccountId32`, we have its typeIn is `AccountId32Like` & typeOut is `AccountId32`
+ *
+ * This registry keep track the list of codecs which follow this convention
+ */
+export declare const looseTypeCodecs: Record<string, AnyShape>;
+export declare function findKnownCodecType(name: string): CodecType;
+export declare function findKnownCodec<I = unknown, O = I>(typeName: string): $.Shape<I, O>;
+export declare function findKnownWrapperCodec(typeName: string): $.AnyShape | undefined;
+export declare function isKnownCodecType(path: string | string[]): boolean;

package/generator/known-codecs.js

@@ -0,0 +1,120 @@
+import * as $ from '@dedot/shape';
+import * as Codecs from '@dedot/codecs';
+import { $AccountId20, $AccountId32, $Bytes, $ConsensusEngineId, $Era, $EthereumAddress, $MultiAddress, $OpaqueExtrinsic, $PrefixedStorageKey, $RawBytes, $StorageData, $StorageKey, $UncheckedExtrinsic, } from '@dedot/codecs';
+import { assert } from '@dedot/utils';
+export const normalizeCodecName = (name) => {
+    return name.startsWith('$') ? name : `$${name}`;
+};
+// Known paths for codecs (primitives) that are shared between
+// different substrate-based blockchains
+const KNOWN_PATHS = [
+    'sp_core::crypto::AccountId32',
+    'sp_runtime::generic::era::Era',
+    'sp_runtime::multiaddress::MultiAddress',
+    /^sp_runtime::DispatchError$/,
+    'sp_runtime::ModuleError',
+    'sp_runtime::TokenError',
+    'sp_arithmetic::ArithmeticError',
+    'sp_runtime::TransactionalError',
+    'frame_support::dispatch::DispatchInfo',
+    'frame_system::Phase',
+    'sp_version::RuntimeVersion',
+    'fp_account::AccountId20',
+    'account::AccountId20',
+    'polkadot_runtime_common::claims::EthereumAddress',
+    'pallet_identity::types::Data',
+    'sp_runtime::generic::digest::Digest',
+    'sp_runtime::generic::digest::DigestItem',
+    'sp_runtime::generic::header::Header',
+    'sp_runtime::generic::unchecked_extrinsic::UncheckedExtrinsic',
+    /^primitive_types::\w+$/,
+    /^sp_arithmetic::per_things::\w+$/,
+    /^sp_arithmetic::fixed_point::\w+$/,
+];
+const WRAPPER_TYPE_REGEX = /^(\w+)<(.*)>$/;
+const TUPLE_TYPE_REGEX = /^\[(.*)]$/;
+const KNOWN_WRAPPER_TYPES = ['Option', 'Vec', 'Result', 'Array'];
+/**
+ * Collection of codec types with loose input types
+ *
+ * Loose codecs are codecs with different typeIn & typeOut,
+ * E.g: Codec `$AccountId32`, we have its typeIn is `AccountId32Like` & typeOut is `AccountId32`
+ *
+ * This registry keep track the list of codecs which follow this convention
+ */
+export const looseTypeCodecs = {
+    $AccountId20,
+    $EthereumAddress,
+    $AccountId32,
+    $ConsensusEngineId,
+    $StorageKey,
+    $StorageData,
+    $PrefixedStorageKey,
+    $Bytes,
+    $RawBytes,
+    $MultiAddress,
+    $OpaqueExtrinsic,
+    $UncheckedExtrinsic,
+    $Era,
+};
+export function findKnownCodecType(name) {
+    const normalizedName = normalizeCodecName(name);
+    const $knownCodec = looseTypeCodecs[normalizedName];
+    if ($knownCodec) {
+        return {
+            name: normalizedName,
+            $codec: $knownCodec,
+            typeIn: `${name}Like`,
+            typeOut: name,
+        };
+    }
+    const $codec = findKnownCodec(name);
+    if ($codec.nativeType && $[name]) {
+        return {
+            name: normalizedName,
+            $codec,
+            typeIn: $codec.nativeType,
+            typeOut: $codec.nativeType,
+        };
+    }
+    return {
+        name: normalizedName,
+        $codec,
+        typeIn: name,
+        typeOut: name,
+    };
+}
+export function findKnownCodec(typeName) {
+    // @ts-ignore
+    const $codec = findKnownWrapperCodec(typeName) || Codecs[normalizeCodecName(typeName)] || $[typeName];
+    assert($codec, `Known codec not found - ${typeName}`);
+    return $codec;
+}
+export function findKnownWrapperCodec(typeName) {
+    const matchNames = typeName.match(WRAPPER_TYPE_REGEX);
+    if (matchNames) {
+        const [_, wrapper, inner] = matchNames;
+        if (KNOWN_WRAPPER_TYPES.includes(wrapper)) {
+            // @ts-ignore
+            const $Wrapper = $[wrapper];
+            if (inner.match(TUPLE_TYPE_REGEX) || inner.match(WRAPPER_TYPE_REGEX)) {
+                return $Wrapper(findKnownWrapperCodec(inner));
+            }
+            const $inners = inner.split(',').map((one) => findKnownCodec(one.trim()));
+            return $Wrapper(...$inners);
+        }
+        throw new Error(`Unknown wrapper type ${wrapper} from ${typeName}`);
+    }
+    else if (typeName.match(TUPLE_TYPE_REGEX)) {
+        const $inner = typeName
+            .slice(1, -1)
+            .split(',')
+            .filter((x) => x)
+            .map((one) => findKnownCodec(one.trim()));
+        return $.Tuple(...$inner);
+    }
+}
+export function isKnownCodecType(path) {
+    const joinedPath = Array.isArray(path) ? path.join('::') : path;
+    return KNOWN_PATHS.some((one) => joinedPath.match(one));
+}