@dedot/codegen 0.0.1-alpha.4 → 0.0.1-alpha.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/codegen",
-  "version": "0.0.1-alpha.4+cef1b29",
+  "version": "0.0.1-alpha.40",
   "description": "Generate types",
   "author": "Thang X. Vu <thang@coongcrafts.io>",
   "homepage": "https://github.com/dedotdev/dedot/tree/main/packages/codegen",
@@ -10,39 +10,38 @@
     "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",
-    "clean": "rm -rf ./dist && rm -rf ./tsconfig.tsbuildinfo ./tsconfig.build.tsbuildinfo"
+    "build": "tsc --project tsconfig.build.json && tsc --project tsconfig.build.cjs.json && yarn copy",
+    "clean": "rm -rf ./dist && rm -rf ./tsconfig.tsbuildinfo ./tsconfig.build.tsbuildinfo",
+    "copy": "cp -R ./src/chaintypes/templates ./dist/chaintypes && cp -R ./src/chaintypes/templates ./dist/cjs/chaintypes && cp -R ./src/typink/templates ./dist/typink && cp -R ./src/typink/templates ./dist/cjs/typink"
   },
   "dependencies": {
-    "@dedot/codecs": "0.0.1-alpha.4+cef1b29",
-    "@dedot/shape": "0.0.1-alpha.4+cef1b29",
-    "@dedot/specs": "0.0.1-alpha.4+cef1b29",
-    "@dedot/utils": "0.0.1-alpha.4+cef1b29",
-    "@polkadot/util": "^12.6.2",
-    "dedot": "0.0.1-alpha.4+cef1b29",
+    "@dedot/api": "0.0.1-alpha.40",
+    "@dedot/codecs": "0.0.1-alpha.40",
+    "@dedot/providers": "0.0.1-alpha.40",
+    "@dedot/runtime-specs": "0.0.1-alpha.40",
+    "@dedot/shape": "0.0.1-alpha.40",
+    "@dedot/types": "0.0.1-alpha.40",
+    "@dedot/utils": "0.0.1-alpha.40",
     "handlebars": "^4.7.8",
-    "prettier": "^3.0.3"
+    "prettier": "^3.3.2"
   },
   "publishConfig": {
     "access": "public",
     "directory": "dist"
   },
   "license": "Apache-2.0",
-  "gitHead": "cef1b29a1f5b0d92fb8c9893dfabff20b658fa5f",
+  "gitHead": "c6c3d9d748851f01ce79c13541754809be6628fc",
   "module": "./index.js",
   "types": "./index.d.ts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./index.d.ts",
-        "default": "./index.js"
-      },
-      "require": {
-        "types": "./index.d.ts",
-        "default": "./cjs/index.js"
-      }
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "require": "./cjs/index.js",
+      "default": "./index.js"
     }
   }
 }

package/{generator/TypesGen.d.ts → shared/BaseTypesGen.d.ts}

@@ -1,6 +1,7 @@
-import { CodecRegistry, Field, MetadataLatest, PortableType, TypeId } from '@dedot/codecs';
-import { TypeImports } from './TypeImports';
-interface NamedType extends PortableType {
+import { Field, PortableType, TypeId } from '@dedot/codecs';
+import { EnumOptions } from '@dedot/shape';
+import { TypeImports } from './TypeImports.js';
+export interface NamedType extends PortableType {
     name: string;
     nameOut: string;
     skip?: boolean;
@@ -8,23 +9,23 @@ interface NamedType extends PortableType {
     suffix?: string;
 }
 export declare const BASIC_KNOWN_TYPES: string[];
-export declare class TypesGen {
+export declare abstract class BaseTypesGen {
     #private;
-    metadata: MetadataLatest;
-    /**
-     * Types will be generated its definition out.
-     */
+    types: PortableType[];
     includedTypes: Record<TypeId, NamedType>;
-    registry: CodecRegistry;
     typeImports: TypeImports;
-    constructor(metadata: MetadataLatest);
-    generate(): Promise<string>;
+    skipTypes: string[];
+    protected constructor(types: PortableType[]);
+    shouldGenerateTypeIn(_id: TypeId): boolean;
     typeCache: Record<string, string>;
     clearCache(): void;
+    includeTypes(): Record<TypeId, NamedType>;
     generateType(typeId: TypeId, nestedLevel?: number, typeOut?: boolean): string;
     generateObjectType(fields: Field[], nestedLevel?: number, typeOut?: boolean): string;
+    cleanPath(path: string[]): string;
     eqlCache: Map<string, boolean>;
     typeEql(idA: number, idB: number, level?: number): boolean;
+    extractDupTypeSuffix(dupTypeId: TypeId, originalTypeId: TypeId, dupCount: number): string;
     addTypeImport(typeName: string | string[]): void;
+    getEnumOptions(_typeId: TypeId): EnumOptions;
 }
-export {};

package/{generator/TypesGen.js → shared/BaseTypesGen.js}

@@ -1,66 +1,93 @@
-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';
-// Skip generate types for these
-// as we do have native types for them
-const SKIP_TYPES = [
-    'BoundedBTreeMap',
-    'BoundedBTreeSet',
-    'BoundedVec',
-    'Box',
-    'BTreeMap',
-    'BTreeSet',
-    'Cow',
-    'Option',
-    'Range',
-    'RangeInclusive',
-    'Result',
-    'WeakBoundedVec',
-    'WrapperKeepOpaque',
-    'WrapperOpaque',
-];
+import { normalizeName, stringPascalCase } from '@dedot/utils';
+import { commentBlock, isNativeType, WRAPPER_TYPE_REGEX } from '../utils.js';
+import { TypeImports } from './TypeImports.js';
+import { checkKnownCodecType, findKnownCodec, findKnownCodecType } from './known-codecs.js';
 // These are common & generic types, so we'll remove these from all paths at index 1
 // This helps make the type name shorter
 const PATH_RM_INDEX_1 = ['generic', 'misc', 'pallet', 'traits', 'types'];
 export const BASIC_KNOWN_TYPES = ['BitSequence', 'Bytes', 'BytesLike', 'FixedBytes', 'FixedArray', 'Result'];
-const WRAPPER_TYPE_REGEX = /^(\w+)(<.*>)$/g;
-export class TypesGen {
-    metadata;
-    /**
-     * Types will be generated its definition out.
-     */
+export class BaseTypesGen {
+    types;
     includedTypes;
-    registry;
     typeImports;
-    constructor(metadata) {
-        this.metadata = metadata;
-        this.registry = new CodecRegistry(this.metadata);
-        this.includedTypes = this.#includedTypes();
+    skipTypes;
+    constructor(types) {
+        this.types = types;
+        this.includedTypes = {};
         this.typeImports = new TypeImports();
+        this.skipTypes = [];
     }
-    generate() {
-        this.clearCache();
-        let defTypeOut = '';
-        Object.values(this.includedTypes)
-            .filter(({ skip, knownType }) => !(skip || knownType))
-            .forEach(({ name, nameOut, id, docs }) => {
-            defTypeOut += `${commentBlock(docs)}export type ${nameOut} = ${this.generateType(id, 0, true)};\n\n`;
-            if (this.#shouldGenerateTypeIn(id)) {
-                defTypeOut += `export type ${name} = ${this.generateType(id)};\n\n`;
-            }
-        });
-        const importTypes = this.typeImports.toImports('./types');
-        const template = compileTemplate('types.hbs');
-        return beautifySourceCode(template({ importTypes, defTypeOut }));
+    shouldGenerateTypeIn(_id) {
+        return false;
     }
     typeCache = {};
     clearCache() {
         this.typeCache = {};
         this.typeImports.clear();
     }
+    includeTypes() {
+        const pathsCount = new Map();
+        const typesWithPath = this.types.filter((one) => one.path.length > 0);
+        const skipIds = [];
+        const typeSuffixes = new Map();
+        typesWithPath.forEach(({ path, id }) => {
+            const joinedPath = path.join('::');
+            if (pathsCount.has(joinedPath)) {
+                // We compare 2 types with the same path here,
+                //  if they are the same type -> skip the current one, keep the first occurrence
+                //  if they are not the same type but has the same path -> we'll try to calculate & add a suffix for the current type name
+                const firstOccurrenceTypeId = pathsCount.get(joinedPath)[0];
+                const sameType = this.typeEql(firstOccurrenceTypeId, id);
+                if (sameType) {
+                    skipIds.push(id);
+                }
+                else {
+                    pathsCount.get(joinedPath).push(id);
+                    typeSuffixes.set(id, this.extractDupTypeSuffix(id, firstOccurrenceTypeId, pathsCount.get(joinedPath).length));
+                }
+            }
+            else {
+                pathsCount.set(joinedPath, [id]);
+            }
+        });
+        return typesWithPath.reduce((o, type) => {
+            const { path, id } = type;
+            const joinedPath = path.join('::');
+            if (this.skipTypes.includes(joinedPath) || this.skipTypes.includes(path.at(-1))) {
+                return o;
+            }
+            const suffix = typeSuffixes.get(id) || '';
+            let knownType = false;
+            let name, nameOut;
+            const [isKnownCodecType, codecName] = checkKnownCodecType(joinedPath);
+            if (isKnownCodecType) {
+                const codecType = findKnownCodecType(codecName);
+                name = codecType.typeIn;
+                nameOut = codecType.typeOut;
+                knownType = true;
+            }
+            else if (PATH_RM_INDEX_1.includes(path[1])) {
+                const newPath = path.slice();
+                newPath.splice(1, 1);
+                name = this.cleanPath(newPath);
+            }
+            else {
+                name = this.cleanPath(path);
+            }
+            if (this.shouldGenerateTypeIn(id)) {
+                nameOut = name;
+                name = name.endsWith('Like') ? name : `${name}Like`;
+            }
+            o[id] = {
+                name: `${name}${suffix}`,
+                nameOut: nameOut ? `${nameOut}${suffix}` : `${name}${suffix}`,
+                knownType,
+                skip: skipIds.includes(id),
+                ...type,
+            };
+            return o;
+        }, {});
+    }
     generateType(typeId, nestedLevel = 0, typeOut = false) {
         if (nestedLevel > 0) {
             const includedDef = this.includedTypes[typeId];
@@ -91,15 +118,15 @@ export class TypesGen {
         return type;
     }
     #generateType(typeId, nestedLevel = 0, typeOut = false) {
-        const def = this.metadata.types[typeId];
+        const def = this.types[typeId];
         if (!def) {
             throw new Error(`Type def not found ${JSON.stringify(def)}`);
         }
-        const { type, path, docs } = def;
-        const { tag, value } = type;
-        switch (tag) {
+        const { typeDef, path, docs } = def;
+        const { type, value } = typeDef;
+        switch (type) {
             case 'Primitive':
-                const $codec = this.registry.findCodec(value.kind);
+                const $codec = findKnownCodec(value.kind);
                 if ($codec.nativeType) {
                     return $codec.nativeType;
                 }
@@ -168,14 +195,14 @@ 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.getEnumOptions(typeId);
                     return membersType
                         .map(([keyName, valueType, docs]) => ({
-                        tag: `${tagKey}: '${keyName}'`,
+                        type: `${tagKey}: '${keyName}'`,
                         value: valueType ? `, ${valueKey}${this.#isOptionalType(valueType) ? '?' : ''}: ${valueType} ` : '',
                         docs,
                     }))
-                        .map(({ tag, value, docs }) => `${commentBlock(docs)}{ ${tag}${value} }`)
+                        .map(({ type, value, docs }) => `${commentBlock(docs)}{ ${type}${value} }`)
                         .join(' | ');
                 }
             }
@@ -197,9 +224,9 @@ export class TypesGen {
                 return this.generateType(value.typeParam, nestedLevel + 1, typeOut);
             case 'Sequence':
             case 'SizedVec': {
-                const fixedSize = tag === 'SizedVec' ? `${value.len}` : null;
-                const $innerType = this.metadata.types[value.typeParam].type;
-                if ($innerType.tag === 'Primitive' && $innerType.value.kind === 'u8') {
+                const fixedSize = type === 'SizedVec' ? `${value.len}` : null;
+                const $innerType = this.types[value.typeParam].typeDef;
+                if ($innerType.type === 'Primitive' && $innerType.value.kind === 'u8') {
                     return fixedSize ? `FixedBytes<${fixedSize}>` : typeOut ? 'Bytes' : 'BytesLike';
                 }
                 else {
@@ -208,7 +235,7 @@ export class TypesGen {
                 }
             }
             default:
-                throw new Error(`Invalid type! ${tag}`);
+                throw new Error(`Invalid type! ${type}`);
         }
     }
     generateObjectType(fields, nestedLevel = 0, typeOut = false) {
@@ -228,69 +255,6 @@ export class TypesGen {
     #isOptionalType(type) {
         return type.endsWith('| undefined');
     }
-    #includedTypes() {
-        const { types } = this.metadata;
-        const pathsCount = new Map();
-        const typesWithPath = types.filter((one) => one.path.length > 0);
-        const skipIds = [];
-        const typeSuffixes = new Map();
-        typesWithPath.forEach(({ path, id }) => {
-            const joinedPath = path.join('::');
-            if (pathsCount.has(joinedPath)) {
-                // We compare 2 types with the same path here,
-                //  if they are the same type -> skip the current one, keep the first occurrence
-                //  if they are not the same type but has the same path -> we'll try to calculate & add a suffix for the current type name
-                const firstOccurrenceTypeId = pathsCount.get(joinedPath)[0];
-                const sameType = this.typeEql(firstOccurrenceTypeId, id);
-                if (sameType) {
-                    skipIds.push(id);
-                }
-                else {
-                    pathsCount.get(joinedPath).push(id);
-                    typeSuffixes.set(id, this.#extractDupTypeSuffix(id, firstOccurrenceTypeId, pathsCount.get(joinedPath).length));
-                }
-            }
-            else {
-                pathsCount.set(joinedPath, [id]);
-            }
-        });
-        return typesWithPath.reduce((o, type) => {
-            const { path, id } = type;
-            const joinedPath = path.join('::');
-            if (SKIP_TYPES.includes(joinedPath) || SKIP_TYPES.includes(path.at(-1))) {
-                return o;
-            }
-            const suffix = typeSuffixes.get(id) || '';
-            let knownType = false;
-            let name, nameOut;
-            if (this.registry.isKnownType(joinedPath)) {
-                const codecType = this.registry.findCodecType(path.at(-1));
-                name = codecType.typeIn;
-                nameOut = codecType.typeOut;
-                knownType = true;
-            }
-            else if (PATH_RM_INDEX_1.includes(path[1])) {
-                const newPath = path.slice();
-                newPath.splice(1, 1);
-                name = this.#cleanPath(newPath);
-            }
-            else {
-                name = this.#cleanPath(path);
-            }
-            if (this.#shouldGenerateTypeIn(id)) {
-                nameOut = name;
-                name = name.endsWith('Like') ? name : `${name}Like`;
-            }
-            o[id] = {
-                name: `${name}${suffix}`,
-                nameOut: nameOut ? `${nameOut}${suffix}` : `${name}${suffix}`,
-                knownType,
-                skip: skipIds.includes(id),
-                ...type,
-            };
-            return o;
-        }, {});
-    }
     #removeGenericPart(typeName) {
         if (typeName.match(WRAPPER_TYPE_REGEX)) {
             return typeName.replace(WRAPPER_TYPE_REGEX, (_, $1) => $1);
@@ -299,27 +263,12 @@ export class TypesGen {
             return typeName;
         }
     }
-    /**
-     * @description Remove duplicated part of the path
-     *
-     * Example:
-     * ["pallet_staking", "pallet", "pallet", "Event"]
-     * => ["pallet_staking", "pallet", "Event"]
-     *
-     * @param path
-     * @private
-     */
-    #cleanPath(path) {
+    cleanPath(path) {
         return path
             .map((one) => stringPascalCase(one))
             .filter((one, idx, currentPath) => idx === 0 || one !== currentPath[idx - 1])
             .join('');
     }
-    #shouldGenerateTypeIn(id) {
-        const { callTypeId } = this.metadata.extrinsic;
-        const palletCallTypeIds = this.registry.portableRegistry.getPalletCallTypeIds();
-        return callTypeId === id || palletCallTypeIds.includes(id);
-    }
     eqlCache = new Map();
     typeEql(idA, idB, level = 0) {
         const cacheKey = `${idA}==${idB}`;
@@ -332,36 +281,36 @@ export class TypesGen {
     #typeEql(idA, idB, lvl = 0) {
         if (idA === idB)
             return true;
-        const { types } = this.metadata;
-        const typeA = types[idA];
-        const typeB = types[idB];
+        const typeA = this.types[idA];
+        const typeB = this.types[idB];
         if (typeA.path.join('::') !== typeB.path.join('::'))
             return false;
-        const { type: defA, params: paramsA } = typeA;
-        const { type: defB, params: paramsB } = typeB;
+        const { typeDef: defA, params: paramsA } = typeA;
+        const { typeDef: defB, params: paramsB } = typeB;
         if (!this.#eqlArray(paramsA, paramsB, (valA, valB) => this.#eqlTypeParam(valA, valB))) {
             return false;
         }
-        if (defA.tag !== defB.tag)
+        if (defA.type !== defB.type)
             return false;
-        if (defA.tag === 'BitSequence')
+        if (defA.type === 'BitSequence')
             return true;
-        if (defA.tag === 'Primitive' && defB.tag === 'Primitive') {
+        if (defA.type === 'Primitive' && defB.type === 'Primitive') {
             return defA.value.kind === defB.value.kind;
         }
-        if ((defA.tag === 'Compact' && defB.tag === 'Compact') || (defA.tag === 'Sequence' && defB.tag === 'Sequence')) {
+        if ((defA.type === 'Compact' && defB.type === 'Compact') ||
+            (defA.type === 'Sequence' && defB.type === 'Sequence')) {
             return this.typeEql(defA.value.typeParam, defB.value.typeParam, lvl + 1);
         }
-        if (defA.tag === 'SizedVec' && defB.tag === 'SizedVec') {
+        if (defA.type === 'SizedVec' && defB.type === 'SizedVec') {
             return defA.value.len === defB.value.len && this.typeEql(defA.value.typeParam, defB.value.typeParam, lvl + 1);
         }
-        if (defA.tag === 'Tuple' && defB.tag === 'Tuple') {
+        if (defA.type === 'Tuple' && defB.type === 'Tuple') {
             return this.#eqlArray(defA.value.fields, defB.value.fields, (val1, val2) => this.typeEql(val1, val2, lvl + 1));
         }
-        if (defA.tag === 'Struct' && defB.tag === 'Struct') {
+        if (defA.type === 'Struct' && defB.type === 'Struct') {
             return this.#eqlFields(defA.value.fields, defB.value.fields, lvl);
         }
-        if (defA.tag === 'Enum' && defB.tag === 'Enum') {
+        if (defA.type === 'Enum' && defB.type === 'Enum') {
             return this.#eqlArray(defA.value.members, defB.value.members, (val1, val2) => val1.name === val2.name && val1.index === val2.index && this.#eqlFields(val1.fields, val2.fields, lvl));
         }
         return false;
@@ -377,19 +326,18 @@ export class TypesGen {
             (param1.typeId === undefined) === (param2.typeId === undefined) &&
             (param1.typeId === undefined || this.#typeEql(param1.typeId, param2.typeId)));
     }
-    #extractDupTypeSuffix(dupTypeId, originalTypeId, dupCount) {
-        const { types } = this.metadata;
-        const originalTypeParams = types[originalTypeId].params;
-        const dupTypeParams = types[dupTypeId].params;
+    extractDupTypeSuffix(dupTypeId, originalTypeId, dupCount) {
+        const originalTypeParams = this.types[originalTypeId].params;
+        const dupTypeParams = this.types[dupTypeId].params;
         const diffParam = dupTypeParams.find((one, idx) => !this.#eqlTypeParam(one, originalTypeParams[idx]));
         // TODO make sure these suffix is unique if a type is duplicated more than 2 times
         if (diffParam?.typeId) {
-            const diffType = types[diffParam.typeId];
+            const diffType = this.types[diffParam.typeId];
             if (diffType.path.length > 0) {
                 return stringPascalCase(diffType.path.at(-1));
             }
-            else if (diffType.type.tag === 'Primitive') {
-                return stringPascalCase(diffType.type.value.kind);
+            else if (diffType.typeDef.type === 'Primitive') {
+                return stringPascalCase(diffType.typeDef.value.kind);
             }
         }
         // Last resort!
@@ -422,11 +370,9 @@ 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);
+    }
+    getEnumOptions(_typeId) {
+        return { tagKey: 'type', valueKey: 'value' };
     }
 }

package/{generator → shared}/TypeImports.d.ts

@@ -1,14 +1,25 @@
+type ImportConfig = {
+    excludeModules?: string[];
+    useSubPaths?: boolean;
+};
 export declare class TypeImports {
     #private;
     portableTypes: Set<string>;
     codecTypes: Set<string>;
     knownTypes: Set<string>;
+    knownJsonRpcTypes: Set<string>;
     outTypes: Set<string>;
+    contractTypes: Set<string>;
+    chainTypes: Set<string>;
     constructor();
     clear(): void;
-    toImports(...excludeModules: string[]): string;
+    toImports(config?: ImportConfig): string;
     addPortableType(...types: string[]): void;
     addCodecType(...types: string[]): void;
     addKnownType(...types: string[]): void;
+    addKnownJsonRpcType(...types: string[]): void;
     addOutType(...types: string[]): void;
+    addContractType(...types: string[]): void;
+    addChainType(...types: string[]): void;
 }
+export {};

package/{generator → shared}/TypeImports.js

@@ -5,30 +5,47 @@ export class TypeImports {
     codecTypes;
     // Known types that're not codecs or chain/portable types defined in @dedot/types
     knownTypes;
+    knownJsonRpcTypes;
     // External types to define explicitly
     outTypes;
+    // Know types defined in @dedot/contracts
+    contractTypes;
+    // Know types defined in @dedot/api/chaintypes or dedot/chaintypes
+    chainTypes;
     constructor() {
         this.portableTypes = new Set();
         this.codecTypes = new Set();
         this.knownTypes = new Set();
+        this.knownJsonRpcTypes = new Set();
         this.outTypes = new Set();
+        this.contractTypes = new Set();
+        this.chainTypes = new Set();
     }
     clear() {
         this.portableTypes.clear();
         this.codecTypes.clear();
         this.knownTypes.clear();
+        this.knownJsonRpcTypes.clear();
         this.outTypes.clear();
+        this.contractTypes.clear();
+        this.chainTypes.clear();
     }
-    toImports(...excludeModules) {
+    toImports(config) {
+        const { excludeModules = [], useSubPaths = false } = config || {};
         // TODO generate outTypes!
+        const prefix = useSubPaths ? '' : '@';
         const toImports = [
-            [this.knownTypes, '@dedot/types'],
-            [this.codecTypes, '@dedot/codecs'],
+            [this.knownTypes, `${prefix}dedot/types`],
+            [this.knownJsonRpcTypes, `${prefix}dedot/types/json-rpc`],
+            [this.codecTypes, `${prefix}dedot/codecs`],
+            [this.contractTypes, `${prefix}dedot/contracts`],
+            [this.chainTypes, prefix ? '@dedot/api/chaintypes' : 'dedot/chaintypes'],
             [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,7 +63,16 @@ export class TypeImports {
     addKnownType(...types) {
         types.forEach((one) => this.knownTypes.add(one));
     }
+    addKnownJsonRpcType(...types) {
+        types.forEach((one) => this.knownJsonRpcTypes.add(one));
+    }
     addOutType(...types) {
         types.forEach((one) => this.outTypes.add(one));
     }
+    addContractType(...types) {
+        types.forEach((one) => this.contractTypes.add(one));
+    }
+    addChainType(...types) {
+        types.forEach((one) => this.chainTypes.add(one));
+    }
 }

package/shared/index.d.ts

@@ -0,0 +1,3 @@
+export * from './BaseTypesGen.js';
+export * from './known-codecs.js';
+export * from './TypeImports.js';

package/shared/index.js

@@ -0,0 +1,3 @@
+export * from './BaseTypesGen.js';
+export * from './known-codecs.js';
+export * from './TypeImports.js';

package/shared/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 checkKnownCodecType(path: string | string[]): [boolean, string];