@dedot/codegen 0.0.1-alpha.26 → 0.0.1-alpha.28

package/cjs/genSupportedChainTypes.js

@@ -38,6 +38,10 @@ const NETWORKS = [
         chain: 'kusamaAssetHub',
         endpoint: 'wss://kusama-asset-hub-rpc.polkadot.io/',
     },
+    {
+        chain: 'rococo',
+        endpoint: 'wss://rococo-rpc.polkadot.io/',
+    },
     {
         chain: 'rococoAssetHub',
         endpoint: 'wss://rococo-asset-hub-rpc.polkadot.io/',
@@ -69,7 +73,7 @@ async function run() {
     console.log('DONE!');
 }
 const getRuntimeVersion = (metadata) => {
-    const registry = new codecs_1.CodecRegistry(metadata.latest);
+    const registry = new codecs_1.PortableRegistry(metadata.latest);
     const executor = new dedot_1.ConstantExecutor({
         registry,
         metadataLatest: metadata.latest,

package/cjs/generator/RpcGen.js

@@ -5,6 +5,7 @@ const specs_1 = require("@dedot/specs");
 const utils_1 = require("@dedot/utils");
 const generator_1 = require("../generator");
 const utils_2 = require("./utils");
+const known_codecs_1 = require("./known-codecs");
 const HIDDEN_RPCS = [
     // Ref: https://github.com/paritytech/polkadot-sdk/blob/43415ef58c143b985e09015cd000dbd65f6d3997/substrate/client/rpc-servers/src/lib.rs#L152C9-L158
     'rpc_methods',
@@ -168,7 +169,7 @@ class RpcGen extends generator_1.ApiGen {
         return type;
     }
     #getCodecType(type, toTypeIn = true) {
-        const { typeIn, typeOut } = this.registry.findCodecType(type);
+        const { typeIn, typeOut } = (0, known_codecs_1.findKnownCodecType)(type);
         return toTypeIn ? typeIn : typeOut;
     }
 }

package/cjs/generator/RuntimeApisGen.js

@@ -96,7 +96,7 @@ class RuntimeApisGen extends RpcGen_1.RpcGen {
     }
     #targetRuntimeApiSpecs() {
         const specs = this.runtimeApis.map(([runtimeApiHash, version]) => {
-            const runtimeApiSpec = (0, specs_1.findRuntimeApiSpec)(runtimeApiHash, version);
+            const runtimeApiSpec = this.#findRuntimeApiSpec(runtimeApiHash, version);
             if (!runtimeApiSpec)
                 return;
             return {
@@ -111,5 +111,9 @@ class RuntimeApisGen extends RpcGen_1.RpcGen {
             return [...o, spec];
         }, []);
     }
+    #findRuntimeApiSpec = (runtimeApiHash, version) => {
+        const runtimeApiName = (0, specs_1.getRuntimeApiNames)().find((one) => (0, utils_2.calculateRuntimeApiHash)(one) === runtimeApiHash);
+        return (0, specs_1.getRuntimeApiSpecs)().find((one) => one.runtimeApiName === runtimeApiName && one.version === version);
+    };
 }
 exports.RuntimeApisGen = RuntimeApisGen;

package/cjs/generator/TypesGen.js

@@ -5,8 +5,9 @@ const util_1 = require("@polkadot/util");
 const codecs_1 = require("@dedot/codecs");
 const utils_1 = require("@dedot/utils");
 const utils_2 = require("./utils");
-const types_1 = require("@dedot/types");
+const known_types_1 = require("./known-types");
 const TypeImports_1 = require("./TypeImports");
+const known_codecs_1 = require("./known-codecs");
 // Skip generate types for these
 // as we do have native types for them
 const SKIP_TYPES = [
@@ -40,7 +41,7 @@ class TypesGen {
     typeImports;
     constructor(metadata) {
         this.metadata = metadata;
-        this.registry = new codecs_1.CodecRegistry(this.metadata);
+        this.registry = new codecs_1.PortableRegistry(this.metadata);
         this.includedTypes = this.#includedTypes();
         this.typeImports = new TypeImports_1.TypeImports();
     }
@@ -102,7 +103,7 @@ class TypesGen {
         const { tag, value } = type;
         switch (tag) {
             case 'Primitive':
-                const $codec = this.registry.findCodec(value.kind);
+                const $codec = (0, known_codecs_1.findKnownCodec)(value.kind);
                 if ($codec.nativeType) {
                     return $codec.nativeType;
                 }
@@ -171,7 +172,7 @@ 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}'`,
@@ -266,8 +267,8 @@ 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 ((0, known_codecs_1.isKnownCodecType)(joinedPath)) {
+                const codecType = (0, known_codecs_1.findKnownCodecType)(path.at(-1));
                 name = codecType.typeIn;
                 nameOut = codecType.typeOut;
                 knownType = true;
@@ -320,7 +321,7 @@ 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();
@@ -425,7 +426,7 @@ class TypesGen {
             this.typeImports.addCodecType(typeName);
             return;
         }
-        if (types_1.registry.has(typeName)) {
+        if (known_types_1.knownTypes.includes(typeName)) {
             this.typeImports.addKnownType(typeName);
         }
         else {

package/cjs/generator/known-codecs.js

@@ -0,0 +1,151 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isKnownCodecType = exports.findKnownWrapperCodec = exports.findKnownCodec = exports.findKnownCodecType = exports.looseTypeCodecs = exports.normalizeCodecName = void 0;
+const $ = __importStar(require("@dedot/shape"));
+const Codecs = __importStar(require("@dedot/codecs"));
+const codecs_1 = require("@dedot/codecs");
+const utils_1 = require("@dedot/utils");
+const normalizeCodecName = (name) => {
+    return name.startsWith('$') ? name : `$${name}`;
+};
+exports.normalizeCodecName = normalizeCodecName;
+// 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
+ */
+exports.looseTypeCodecs = {
+    $AccountId20: codecs_1.$AccountId20,
+    $EthereumAddress: codecs_1.$EthereumAddress,
+    $AccountId32: codecs_1.$AccountId32,
+    $ConsensusEngineId: codecs_1.$ConsensusEngineId,
+    $StorageKey: codecs_1.$StorageKey,
+    $StorageData: codecs_1.$StorageData,
+    $PrefixedStorageKey: codecs_1.$PrefixedStorageKey,
+    $Bytes: codecs_1.$Bytes,
+    $RawBytes: codecs_1.$RawBytes,
+    $MultiAddress: codecs_1.$MultiAddress,
+    $OpaqueExtrinsic: codecs_1.$OpaqueExtrinsic,
+    $UncheckedExtrinsic: codecs_1.$UncheckedExtrinsic,
+    $Era: codecs_1.$Era,
+};
+function findKnownCodecType(name) {
+    const normalizedName = (0, exports.normalizeCodecName)(name);
+    const $knownCodec = exports.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,
+    };
+}
+exports.findKnownCodecType = findKnownCodecType;
+function findKnownCodec(typeName) {
+    // @ts-ignore
+    const $codec = findKnownWrapperCodec(typeName) || Codecs[(0, exports.normalizeCodecName)(typeName)] || $[typeName];
+    (0, utils_1.assert)($codec, `Known codec not found - ${typeName}`);
+    return $codec;
+}
+exports.findKnownCodec = findKnownCodec;
+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);
+    }
+}
+exports.findKnownWrapperCodec = findKnownWrapperCodec;
+function isKnownCodecType(path) {
+    const joinedPath = Array.isArray(path) ? path.join('::') : path;
+    return KNOWN_PATHS.some((one) => joinedPath.match(one));
+}
+exports.isKnownCodecType = isKnownCodecType;

package/cjs/generator/known-types.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.knownTypes = void 0;
+/**
+ * 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
+ */
+exports.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/cjs/packageInfo.js

@@ -2,4 +2,4 @@
 // THIS FILE IS AUTO-GENERATED, DO NOT EDIT!
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.packageInfo = void 0;
-exports.packageInfo = { name: '@dedot/codegen', version: '0.0.1-alpha.25' };
+exports.packageInfo = { name: '@dedot/codegen', version: '0.0.1-alpha.27' };

package/genSupportedChainTypes.js

@@ -1,7 +1,7 @@
 import { generateTypes, generateTypesFromChain } from './index';
 import { rpc } from '@polkadot/types-support/metadata/static-substrate';
 import staticSubstrate from '@polkadot/types-support/metadata/v15/substrate-hex';
-import { $Metadata, CodecRegistry } from '@dedot/codecs';
+import { $Metadata, PortableRegistry } from '@dedot/codecs';
 import { ConstantExecutor } from 'dedot';
 const NETWORKS = [
     {
@@ -33,6 +33,10 @@ const NETWORKS = [
         chain: 'kusamaAssetHub',
         endpoint: 'wss://kusama-asset-hub-rpc.polkadot.io/',
     },
+    {
+        chain: 'rococo',
+        endpoint: 'wss://rococo-rpc.polkadot.io/',
+    },
     {
         chain: 'rococoAssetHub',
         endpoint: 'wss://rococo-asset-hub-rpc.polkadot.io/',
@@ -64,7 +68,7 @@ async function run() {
     console.log('DONE!');
 }
 const getRuntimeVersion = (metadata) => {
-    const registry = new CodecRegistry(metadata.latest);
+    const registry = new PortableRegistry(metadata.latest);
     const executor = new ConstantExecutor({
         registry,
         metadataLatest: metadata.latest,

package/generator/ApiGen.d.ts

@@ -44,7 +44,7 @@ export declare abstract class ApiGen {
             } | {
                 tag: "Primitive";
                 value: {
-                    kind: "bool" | "char" | "str" | "u8" | "u16" | "u32" | "u64" | "u128" | "u256" | "i8" | "i16" | "i32" | "i64" | "i128" | "i256";
+                    kind: "bool" | "u8" | "i8" | "u16" | "i16" | "u32" | "i32" | "u64" | "i64" | "u128" | "i128" | "u256" | "i256" | "str" | "char";
                 };
             } | {
                 tag: "Compact";
@@ -134,5 +134,5 @@ export declare abstract class ApiGen {
             }>;
         };
     };
-    get registry(): import("@dedot/codecs").CodecRegistry;
+    get registry(): import("@dedot/codecs").PortableRegistry;
 }

package/generator/RpcGen.js

@@ -2,6 +2,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 { findKnownCodecType } from './known-codecs';
 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 +166,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.js

@@ -1,4 +1,4 @@
-import { findRuntimeApiSpec } from '@dedot/specs';
+import { getRuntimeApiNames, getRuntimeApiSpecs } from '@dedot/specs';
 import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
 import { calculateRuntimeApiHash, stringSnakeCase } from '@dedot/utils';
 import { RpcGen } from './RpcGen';
@@ -93,7 +93,7 @@ export class RuntimeApisGen extends RpcGen {
     }
     #targetRuntimeApiSpecs() {
         const specs = this.runtimeApis.map(([runtimeApiHash, version]) => {
-            const runtimeApiSpec = findRuntimeApiSpec(runtimeApiHash, version);
+            const runtimeApiSpec = this.#findRuntimeApiSpec(runtimeApiHash, version);
             if (!runtimeApiSpec)
                 return;
             return {
@@ -108,4 +108,8 @@ export class RuntimeApisGen extends RpcGen {
             return [...o, spec];
         }, []);
     }
+    #findRuntimeApiSpec = (runtimeApiHash, version) => {
+        const runtimeApiName = getRuntimeApiNames().find((one) => calculateRuntimeApiHash(one) === runtimeApiHash);
+        return getRuntimeApiSpecs().find((one) => one.runtimeApiName === runtimeApiName && one.version === version);
+    };
 }

package/generator/TypesGen.d.ts

@@ -1,4 +1,4 @@
-import { CodecRegistry, Field, MetadataLatest, PortableType, TypeId } from '@dedot/codecs';
+import { PortableRegistry, Field, MetadataLatest, PortableType, TypeId } from '@dedot/codecs';
 import { TypeImports } from './TypeImports';
 interface NamedType extends PortableType {
     name: 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,10 @@
 import { stringPascalCase } from '@polkadot/util';
-import { CodecRegistry } from '@dedot/codecs';
+import { PortableRegistry } from '@dedot/codecs';
 import { isNativeType, normalizeName } from '@dedot/utils';
 import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
-import { registry } from '@dedot/types';
+import { knownTypes } from './known-types';
 import { TypeImports } from './TypeImports';
+import { findKnownCodec, findKnownCodecType, isKnownCodecType } from './known-codecs';
 // Skip generate types for these
 // as we do have native types for them
 const SKIP_TYPES = [
@@ -37,7 +38,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 +100,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 +169,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 +264,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 +318,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 +423,7 @@ export class TypesGen {
             this.typeImports.addCodecType(typeName);
             return;
         }
-        if (registry.has(typeName)) {
+        if (knownTypes.includes(typeName)) {
             this.typeImports.addKnownType(typeName);
         }
         else {

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/codegen",
-  "version": "0.0.1-alpha.26",
+  "version": "0.0.1-alpha.28",
   "description": "Generate types",
   "author": "Thang X. Vu <thang@coongcrafts.io>",
   "homepage": "https://github.com/dedotdev/dedot/tree/main/packages/codegen",
@@ -10,6 +10,7 @@
     "url": "https://github.com/dedotdev/dedot.git"
   },
   "main": "./cjs/index.js",
+  "sideEffects": false,
   "type": "module",
   "scripts": {
     "build": "tsc --project tsconfig.build.json && tsc --project tsconfig.build.cjs.json && yarn copy",
@@ -17,12 +18,12 @@
     "copy": "cp -R ./src/templates ./dist && cp -R ./src/templates ./dist/cjs"
   },
   "dependencies": {
-    "@dedot/codecs": "0.0.1-alpha.26",
-    "@dedot/shape": "0.0.1-alpha.26",
-    "@dedot/specs": "0.0.1-alpha.26",
-    "@dedot/utils": "0.0.1-alpha.26",
+    "@dedot/codecs": "0.0.1-alpha.28",
+    "@dedot/shape": "0.0.1-alpha.28",
+    "@dedot/specs": "0.0.1-alpha.28",
+    "@dedot/utils": "0.0.1-alpha.28",
     "@polkadot/util": "^12.6.2",
-    "dedot": "0.0.1-alpha.26",
+    "dedot": "0.0.1-alpha.28",
     "handlebars": "^4.7.8",
     "prettier": "^3.0.3"
   },
@@ -31,7 +32,7 @@
     "directory": "dist"
   },
   "license": "Apache-2.0",
-  "gitHead": "5b114a0d2359316f07654915f3c03b44761cac73",
+  "gitHead": "564588ef7baeb1eca72c594b8dccd5c71181e81e",
   "module": "./index.js",
   "types": "./index.d.ts",
   "exports": {

package/packageInfo.js

@@ -1,3 +1,3 @@
 // THIS FILE IS AUTO-GENERATED, DO NOT EDIT!
 
-export const packageInfo = { name: '@dedot/codegen', version: '0.0.1-alpha.26' };
+export const packageInfo = { name: '@dedot/codegen', version: '0.0.1-alpha.28' };