@dedot/codegen 0.0.1-alpha.3 → 0.0.1-alpha.31

package/generator/ConstsGen.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 '../generator/index.js';
+import { beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
 export class ConstsGen extends ApiGen {
     generate() {
         const { pallets } = this.metadata;
@@ -15,7 +14,7 @@ export class ConstsGen extends ApiGen {
                 docs: one.docs,
             }));
             defTypeOut += commentBlock(`Pallet \`${pallet.name}\`'s constants`);
-            defTypeOut += `${stringLowerFirst(pallet.name)}: {
+            defTypeOut += `${stringCamelCase(pallet.name)}: {
         ${typedConstants.map(({ name, type, docs }) => `${commentBlock(docs)}${name}: ${type}`).join(',\n')}
           
         ${commentBlock('Generic pallet constant')}[name: string]: any,

package/generator/ErrorsGen.d.ts

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

package/generator/ErrorsGen.js

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

package/generator/EventsGen.d.ts

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

package/generator/EventsGen.js

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

package/generator/IndexGen.d.ts

@@ -1,6 +1,5 @@
-import { NetworkInfo } from '../types';
 export declare class IndexGen {
-    readonly networkInfo: NetworkInfo;
-    constructor(networkInfo: NetworkInfo);
+    readonly chain: string;
+    constructor(chain: string);
     generate(): Promise<string>;
 }

package/generator/IndexGen.js

@@ -1,13 +1,12 @@
-import { beautifySourceCode, compileTemplate } from './utils';
-import { stringPascalCase } from '@polkadot/util';
+import { beautifySourceCode, compileTemplate } from './utils.js';
+import { stringPascalCase } from '@dedot/utils';
 export class IndexGen {
-    networkInfo;
-    constructor(networkInfo) {
-        this.networkInfo = networkInfo;
+    chain;
+    constructor(chain) {
+        this.chain = chain;
     }
     async generate() {
-        const { chain } = this.networkInfo;
-        const interfaceName = stringPascalCase(chain);
+        const interfaceName = stringPascalCase(this.chain);
         const template = compileTemplate('index.hbs');
         return beautifySourceCode(template({ interfaceName }));
     }

package/generator/QueryGen.d.ts

@@ -1,4 +1,4 @@
-import { ApiGen } from '../generator';
+import { ApiGen } from '../generator/index.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 '../generator/index.js';
+import { beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
 export class QueryGen extends ApiGen {
     generate() {
         const { pallets } = this.metadata;
@@ -15,7 +14,7 @@ export class QueryGen extends ApiGen {
             const queries = storage.entries.map((one) => this.#generateEntry(one));
             const queryDefs = queries.map(({ name, valueType, keyType, docs }) => `${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;

package/generator/RpcGen.d.ts

@@ -1,4 +1,4 @@
-import { ApiGen, TypesGen } from '../generator';
+import { ApiGen, TypesGen } from '../generator/index.js';
 export declare class RpcGen extends ApiGen {
     #private;
     readonly typesGen: TypesGen;

package/generator/RpcGen.js

@@ -1,7 +1,7 @@
 import { findAliasRpcSpec, findRpcSpec, isUnsubscribeMethod } from '@dedot/specs';
-import { isNativeType } from '@dedot/utils';
-import { ApiGen } from '../generator';
-import { beautifySourceCode, commentBlock, compileTemplate, TUPLE_TYPE_REGEX, WRAPPER_TYPE_REGEX } from './utils';
+import { ApiGen } from '../generator/index.js';
+import { isNativeType, beautifySourceCode, commentBlock, compileTemplate, TUPLE_TYPE_REGEX, WRAPPER_TYPE_REGEX, } from './utils.js';
+import { findKnownCodecType } from './known-codecs.js';
 const HIDDEN_RPCS = [
     // Ref: https://github.com/paritytech/polkadot-sdk/blob/43415ef58c143b985e09015cd000dbd65f6d3997/substrate/client/rpc-servers/src/lib.rs#L152C9-L158
     'rpc_methods',
@@ -165,7 +165,7 @@ export class RpcGen extends ApiGen {
         return type;
     }
     #getCodecType(type, toTypeIn = true) {
-        const { typeIn, typeOut } = this.registry.findCodecType(type);
+        const { typeIn, typeOut } = findKnownCodecType(type);
         return toTypeIn ? typeIn : typeOut;
     }
 }

package/generator/RuntimeApisGen.d.ts

@@ -1,5 +1,5 @@
-import { TypesGen } from './TypesGen';
-import { RpcGen } from './RpcGen';
+import { TypesGen } from './TypesGen.js';
+import { RpcGen } from './RpcGen.js';
 export declare class RuntimeApisGen extends RpcGen {
     #private;
     readonly typesGen: TypesGen;

package/generator/RuntimeApisGen.js

@@ -1,8 +1,7 @@
-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';
+import { getRuntimeApiNames, getRuntimeApiSpecs } from '@dedot/specs';
+import { beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
+import { calcRuntimeApiHash, stringSnakeCase, stringCamelCase } from '@dedot/utils';
+import { RpcGen } from './RpcGen.js';
 export class RuntimeApisGen extends RpcGen {
     typesGen;
     runtimeApis;
@@ -18,7 +17,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')} 
               
@@ -27,18 +26,20 @@ export class RuntimeApisGen extends RpcGen {
             });
         }
         else {
-            const specsByModule = this.#runtimeApisSpecsByModule();
-            Object.values(specsByModule).forEach((specs) => {
-                specs.forEach(({ methods, runtimeApiName, runtimeApiHash, version }) => {
-                    runtimeCallsOut += commentBlock(`@runtimeapi: ${runtimeApiName} - ${runtimeApiHash}`, `@version: ${version}`);
-                    runtimeCallsOut += `${stringCamelCase(runtimeApiName)}: {
+            const specs = this.#targetRuntimeApiSpecs();
+            specs.forEach(({ methods, runtimeApiName, runtimeApiHash, version }) => {
+                runtimeCallsOut += commentBlock(`@runtimeapi: ${runtimeApiName} - ${runtimeApiHash}`, `@version: ${version}`);
+                runtimeCallsOut += `${stringCamelCase(runtimeApiName)}: {
             ${Object.keys(methods)
-                        .map((methodName) => this.#generateMethodDefFromSpec({ ...methods[methodName], runtimeApiName, methodName }))
-                        .join('\n')} 
+                    .map((methodName) => this.#generateMethodDefFromSpec({
+                    ...methods[methodName],
+                    runtimeApiName,
+                    methodName,
+                }))
+                    .join('\n')} 
               
             ${commentBlock('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod
           }`;
-                });
             });
         }
         const importTypes = this.typesGen.typeImports.toImports();
@@ -89,9 +90,9 @@ export class RuntimeApisGen extends RpcGen {
             .join(', ');
         return `${commentBlock(docs, '\n', defaultDocs, typedInputs.map(({ type, name }) => `@param {${type}} ${name}`))}${stringCamelCase(methodName)}: GenericRuntimeApiMethod<(${paramsOut}) => Promise<${typeOut}>>`;
     }
-    #runtimeApisSpecsByModule() {
+    #targetRuntimeApiSpecs() {
         const specs = this.runtimeApis.map(([runtimeApiHash, version]) => {
-            const runtimeApiSpec = findRuntimeApiSpec(runtimeApiHash, version);
+            const runtimeApiSpec = this.#findRuntimeApiSpec(runtimeApiHash, version);
             if (!runtimeApiSpec)
                 return;
             return {
@@ -103,14 +104,11 @@ export class RuntimeApisGen extends RpcGen {
             if (!spec) {
                 return o;
             }
-            const { moduleName } = spec;
-            if (!moduleName) {
-                return o;
-            }
-            return {
-                ...o,
-                [moduleName]: o[moduleName] ? [...o[moduleName], spec] : [spec],
-            };
-        }, {});
+            return [...o, spec];
+        }, []);
     }
+    #findRuntimeApiSpec = (runtimeApiHash, version) => {
+        const runtimeApiName = getRuntimeApiNames().find((one) => calcRuntimeApiHash(one) === runtimeApiHash);
+        return getRuntimeApiSpecs().find((one) => one.runtimeApiName === runtimeApiName && one.version === version);
+    };
 }

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/TypesGen.d.ts

@@ -1,5 +1,5 @@
-import { CodecRegistry, Field, MetadataLatest, PortableType, TypeId } from '@dedot/codecs';
-import { TypeImports } from './TypeImports';
+import { PortableRegistry, Field, MetadataLatest, 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,9 @@
-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 { isNativeType, beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
+import { knownTypes } from './known-types.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 +37,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 +99,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 +168,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 +263,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 +317,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,7 +422,7 @@ export class TypesGen {
             this.typeImports.addCodecType(typeName);
             return;
         }
-        if (registry.has(typeName)) {
+        if (knownTypes.includes(typeName)) {
             this.typeImports.addKnownType(typeName);
         }
         else {

package/generator/dirname.d.ts

@@ -0,0 +1 @@
+export function currentDirname(): string;

package/generator/dirname.js

@@ -0,0 +1,6 @@
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+export const currentDirname = () => {
+    const __filename = fileURLToPath(import.meta.url);
+    return dirname(__filename);
+};

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 './RpcGen.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 './RpcGen.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));
+}

package/generator/known-types.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Known type names registered in @dedot/types
+ * Since TS interfaces are trim-off when compiling,
+ * So we need to register them explicitly here for RPC codegen process
+ */
+export declare const knownTypes: string[];

package/generator/known-types.js

@@ -0,0 +1,30 @@
+/**
+ * Known type names registered in @dedot/types
+ * Since TS interfaces are trim-off when compiling,
+ * So we need to register them explicitly here for RPC codegen process
+ */
+export const knownTypes = [
+    'ExtrinsicOrHash',
+    'EpochAuthorship',
+    'BlockStats',
+    'Prevotes',
+    'Precommits',
+    'RoundState',
+    'ReportedRoundStates',
+    'JustificationNotification',
+    'EncodedFinalityProofs',
+    'LeavesProof',
+    'StorageKind',
+    'RpcMethods',
+    'ReadProof',
+    'StorageChangeSet',
+    'TraceBlockResponse',
+    'MigrationStatusResult',
+    'ChainType',
+    'ChainProperties',
+    'Health',
+    'SyncState',
+    'PeerInfo',
+    'NodeRole',
+    'NetworkState',
+];

package/generator/utils.d.ts

@@ -1,7 +1,6 @@
 export declare const WRAPPER_TYPE_REGEX: RegExp;
 export declare const TUPLE_TYPE_REGEX: RegExp;
 export declare const commentBlock: (...docs: (string | string[])[]) => string;
-export declare const resolveFilePath: (relativePath: string | string[]) => string;
 export declare const beautifySourceCode: (source: string) => Promise<string>;
 export declare const compileTemplate: (templateFileName: string) => HandlebarsTemplateDelegate<any>;
 /**
@@ -9,3 +8,8 @@ export declare const compileTemplate: (templateFileName: string) => HandlebarsTe
  * @param word
  */
 export declare const isReservedWord: (word: string) => boolean;
+/**
+ * Check if a type is native JS/TS type
+ * @param type
+ */
+export declare const isNativeType: (type: string) => boolean;