@dedot/codegen 0.0.1-next.020a0293.9 → 0.0.1-next.2d39ff2d.5

package/cjs/generator/index.js

@@ -14,13 +14,13 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./TypesGen"), exports);
-__exportStar(require("./ApiGen"), exports);
-__exportStar(require("./ConstsGen"), exports);
-__exportStar(require("./QueryGen"), exports);
-__exportStar(require("./RpcGen"), exports);
-__exportStar(require("./IndexGen"), exports);
-__exportStar(require("./ErrorsGen"), exports);
-__exportStar(require("./EventsGen"), exports);
-__exportStar(require("./TxGen"), exports);
-__exportStar(require("./RuntimeApisGen"), exports);
+__exportStar(require("./TypesGen.js"), exports);
+__exportStar(require("./ApiGen.js"), exports);
+__exportStar(require("./ConstsGen.js"), exports);
+__exportStar(require("./QueryGen.js"), exports);
+__exportStar(require("./RpcGen.js"), exports);
+__exportStar(require("./IndexGen.js"), exports);
+__exportStar(require("./ErrorsGen.js"), exports);
+__exportStar(require("./EventsGen.js"), exports);
+__exportStar(require("./TxGen.js"), exports);
+__exportStar(require("./RuntimeApisGen.js"), exports);

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/index.js

@@ -27,7 +27,7 @@ exports.generateTypes = exports.generateTypesFromChain = void 0;
 const dedot_1 = require("dedot");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const generator_1 = require("./generator");
+const index_js_1 = require("./generator/index.js");
 const util_1 = require("@polkadot/util");
 async function generateTypesFromChain(network, endpoint, outDir) {
     const api = await dedot_1.Dedot.create(endpoint);
@@ -54,15 +54,15 @@ async function generateTypes(network, metadata, rpcMethods, runtimeApis, outDir
     if (!fs.existsSync(dirPath)) {
         fs.mkdirSync(dirPath, { recursive: true });
     }
-    const typesGen = new generator_1.TypesGen(metadata);
-    const constsGen = new generator_1.ConstsGen(typesGen);
-    const queryGen = new generator_1.QueryGen(typesGen);
-    const rpcGen = new generator_1.RpcGen(typesGen, rpcMethods);
-    const indexGen = new generator_1.IndexGen(network);
-    const errorsGen = new generator_1.ErrorsGen(typesGen);
-    const eventsGen = new generator_1.EventsGen(typesGen);
-    const runtimeApisGen = new generator_1.RuntimeApisGen(typesGen, runtimeApis);
-    const txGen = new generator_1.TxGen(typesGen);
+    const typesGen = new index_js_1.TypesGen(metadata);
+    const constsGen = new index_js_1.ConstsGen(typesGen);
+    const queryGen = new index_js_1.QueryGen(typesGen);
+    const rpcGen = new index_js_1.RpcGen(typesGen, rpcMethods);
+    const indexGen = new index_js_1.IndexGen(network);
+    const errorsGen = new index_js_1.ErrorsGen(typesGen);
+    const eventsGen = new index_js_1.EventsGen(typesGen);
+    const runtimeApisGen = new index_js_1.RuntimeApisGen(typesGen, runtimeApis);
+    const txGen = new index_js_1.TxGen(typesGen);
     fs.writeFileSync(defTypesFileName, await typesGen.generate());
     fs.writeFileSync(errorsFileName, await errorsGen.generate());
     fs.writeFileSync(eventsFileName, await eventsGen.generate());

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.26' };
+exports.packageInfo = { name: '@dedot/codegen', version: '0.0.1-alpha.28' };

package/genSupportedChainTypes.js

@@ -1,7 +1,7 @@
-import { generateTypes, generateTypesFromChain } from './index';
+import { generateTypes, generateTypesFromChain } from './index.js';
 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

@@ -1,4 +1,4 @@
-import { TypesGen } from '../generator';
+import { TypesGen } from '../generator/index.js';
 export declare abstract class ApiGen {
     readonly typesGen: TypesGen;
     constructor(typesGen: TypesGen);
@@ -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/ConstsGen.d.ts

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

package/generator/ConstsGen.js

@@ -1,7 +1,7 @@
 import { stringLowerFirst } from '@polkadot/util';
 import { normalizeName } from '@dedot/utils';
-import { ApiGen } from '../generator';
-import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
+import { ApiGen } from '../generator/index.js';
+import { beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
 export class ConstsGen extends ApiGen {
     generate() {
         const { pallets } = this.metadata;

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,5 +1,5 @@
-import { ApiGen } from './ApiGen';
-import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
+import { ApiGen } from './ApiGen.js';
+import { beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
 import { stringCamelCase, stringPascalCase } from '@polkadot/util';
 import { assert } from '@dedot/utils';
 export class ErrorsGen extends ApiGen {

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,5 +1,5 @@
-import { ApiGen } from './ApiGen';
-import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
+import { ApiGen } from './ApiGen.js';
+import { beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
 import { stringCamelCase, stringPascalCase } from '@polkadot/util';
 import { assert } from '@dedot/utils';
 export class EventsGen extends ApiGen {

package/generator/IndexGen.d.ts

@@ -1,4 +1,4 @@
-import { NetworkInfo } from '../types';
+import { NetworkInfo } from '../types.js';
 export declare class IndexGen {
     readonly networkInfo: NetworkInfo;
     constructor(networkInfo: NetworkInfo);

package/generator/IndexGen.js

@@ -1,4 +1,4 @@
-import { beautifySourceCode, compileTemplate } from './utils';
+import { beautifySourceCode, compileTemplate } from './utils.js';
 import { stringPascalCase } from '@polkadot/util';
 export class IndexGen {
     networkInfo;

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,7 @@
 import { stringLowerFirst } from '@polkadot/util';
 import { normalizeName } from '@dedot/utils';
-import { ApiGen } from '../generator';
-import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
+import { ApiGen } from '../generator/index.js';
+import { beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
 export class QueryGen extends ApiGen {
     generate() {
         const { pallets } = this.metadata;

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,8 @@
 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 { 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 +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.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,7 +1,7 @@
-import { findRuntimeApiSpec } from '@dedot/specs';
-import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
+import { getRuntimeApiNames, getRuntimeApiSpecs } from '@dedot/specs';
+import { beautifySourceCode, commentBlock, compileTemplate } from './utils.js';
 import { calculateRuntimeApiHash, stringSnakeCase } from '@dedot/utils';
-import { RpcGen } from './RpcGen';
+import { RpcGen } from './RpcGen.js';
 import { stringCamelCase } from '@polkadot/util';
 export class RuntimeApisGen extends RpcGen {
     typesGen;
@@ -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/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 { ApiGen } from '../generator/index.js';
 import { stringCamelCase, stringPascalCase } from '@polkadot/util';
-import { beautifySourceCode, commentBlock, compileTemplate, isReservedWord } from './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,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 { TypeImports } from './TypeImports';
+import { 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 +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/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;