@dedot/codegen 0.0.1-next.8beb88c3.11 → 0.0.1-next.8d06d348.17

package/cjs/generator/RpcGen.js

@@ -168,7 +168,7 @@ class RpcGen extends generator_1.ApiGen {
         return type;
     }
     #getCodecType(type, toTypeIn = true) {
-        const { typeIn, typeOut } = this.registry.findCodecType(type);
+        const { typeIn, typeOut } = this.typesGen.knownCodecRegistry.findCodecType(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

@@ -7,6 +7,7 @@ const utils_1 = require("@dedot/utils");
 const utils_2 = require("./utils");
 const types_1 = require("@dedot/types");
 const TypeImports_1 = require("./TypeImports");
+const helpers_1 = require("../helpers");
 // Skip generate types for these
 // as we do have native types for them
 const SKIP_TYPES = [
@@ -37,10 +38,12 @@ class TypesGen {
      */
     includedTypes;
     registry;
+    knownCodecRegistry;
     typeImports;
     constructor(metadata) {
         this.metadata = metadata;
         this.registry = new codecs_1.CodecRegistry(this.metadata);
+        this.knownCodecRegistry = new helpers_1.KnownCodecRegistry();
         this.includedTypes = this.#includedTypes();
         this.typeImports = new TypeImports_1.TypeImports();
     }
@@ -102,7 +105,7 @@ class TypesGen {
         const { tag, value } = type;
         switch (tag) {
             case 'Primitive':
-                const $codec = this.registry.findCodec(value.kind);
+                const $codec = this.knownCodecRegistry.findCodec(value.kind);
                 if ($codec.nativeType) {
                     return $codec.nativeType;
                 }
@@ -266,8 +269,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 (this.knownCodecRegistry.isKnownType(joinedPath)) {
+                const codecType = this.knownCodecRegistry.findCodecType(path.at(-1));
                 name = codecType.typeIn;
                 nameOut = codecType.typeOut;
                 knownType = true;

package/cjs/helpers/KnownCodecRegistry.js

@@ -0,0 +1,163 @@
+"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.KnownCodecRegistry = exports.looseTypeCodecs = exports.normalizeCodecName = void 0;
+const $ = __importStar(require("@dedot/shape"));
+const Codecs = __importStar(require("@dedot/codecs"));
+const codecs_1 = require("@dedot/codecs");
+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,
+};
+/**
+ * A codec registry for both known and portable codecs,
+ */
+class KnownCodecRegistry {
+    findCodec(name) {
+        return this.#findKnownCodec(name);
+    }
+    findCodecType(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 = this.findCodec(name);
+        if ($codec.nativeType && $[name]) {
+            return {
+                name: normalizedName,
+                $codec,
+                typeIn: $codec.nativeType,
+                typeOut: $codec.nativeType,
+            };
+        }
+        return {
+            name: normalizedName,
+            $codec,
+            typeIn: name,
+            typeOut: name,
+        };
+    }
+    #findKnownCodec(typeName) {
+        // @ts-ignore
+        const $codec = this.#findKnownWrapperCodec(typeName) || Codecs[(0, exports.normalizeCodecName)(typeName)] || $[typeName];
+        if (!$codec) {
+            throw new Error(`Unsupported codec - ${typeName}`);
+        }
+        // This only works with top-level $.deferred codecs
+        // We should make it work for nested $.deferred codecs as well
+        if ($codec.metadata && $codec.metadata[0].name === '$.deferred') {
+            const getShape = $codec.metadata[0].args[0];
+            return $.deferred(() => getShape(this));
+        }
+        return $codec;
+    }
+    #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(this.#findKnownWrapperCodec(inner));
+                }
+                const $inners = inner.split(',').map((one) => this.#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) => this.#findKnownCodec(one.trim()));
+            return $.Tuple(...$inner);
+        }
+    }
+    isKnownType(path) {
+        const joinedPath = Array.isArray(path) ? path.join('::') : path;
+        return KNOWN_PATHS.some((one) => joinedPath.match(one));
+    }
+}
+exports.KnownCodecRegistry = KnownCodecRegistry;

package/cjs/helpers/index.js

@@ -0,0 +1,17 @@
+"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 __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("./KnownCodecRegistry"), exports);

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";

package/generator/RpcGen.js

@@ -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 } = this.typesGen.knownCodecRegistry.findCodecType(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,5 +1,6 @@
 import { CodecRegistry, Field, MetadataLatest, PortableType, TypeId } from '@dedot/codecs';
 import { TypeImports } from './TypeImports';
+import { KnownCodecRegistry } from '../helpers';
 interface NamedType extends PortableType {
     name: string;
     nameOut: string;
@@ -16,6 +17,7 @@ export declare class TypesGen {
      */
     includedTypes: Record<TypeId, NamedType>;
     registry: CodecRegistry;
+    knownCodecRegistry: KnownCodecRegistry;
     typeImports: TypeImports;
     constructor(metadata: MetadataLatest);
     generate(): Promise<string>;

package/generator/TypesGen.js

@@ -4,6 +4,7 @@ import { isNativeType, normalizeName } from '@dedot/utils';
 import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
 import { registry } from '@dedot/types';
 import { TypeImports } from './TypeImports';
+import { KnownCodecRegistry } from '../helpers';
 // Skip generate types for these
 // as we do have native types for them
 const SKIP_TYPES = [
@@ -34,10 +35,12 @@ export class TypesGen {
      */
     includedTypes;
     registry;
+    knownCodecRegistry;
     typeImports;
     constructor(metadata) {
         this.metadata = metadata;
         this.registry = new CodecRegistry(this.metadata);
+        this.knownCodecRegistry = new KnownCodecRegistry();
         this.includedTypes = this.#includedTypes();
         this.typeImports = new TypeImports();
     }
@@ -99,7 +102,7 @@ export class TypesGen {
         const { tag, value } = type;
         switch (tag) {
             case 'Primitive':
-                const $codec = this.registry.findCodec(value.kind);
+                const $codec = this.knownCodecRegistry.findCodec(value.kind);
                 if ($codec.nativeType) {
                     return $codec.nativeType;
                 }
@@ -263,8 +266,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 (this.knownCodecRegistry.isKnownType(joinedPath)) {
+                const codecType = this.knownCodecRegistry.findCodecType(path.at(-1));
                 name = codecType.typeIn;
                 nameOut = codecType.typeOut;
                 knownType = true;

package/helpers/KnownCodecRegistry.d.ts

@@ -0,0 +1,22 @@
+import * as $ from '@dedot/shape';
+import { AnyShape } from '@dedot/shape';
+import { CodecType, CodecName } from '../types';
+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>;
+/**
+ * A codec registry for both known and portable codecs,
+ */
+export declare class KnownCodecRegistry {
+    #private;
+    findCodec<I = unknown, O = I>(name: string): $.Shape<I, O>;
+    findCodecType(name: string): CodecType;
+    isKnownType(path: string | string[]): boolean;
+}

package/helpers/KnownCodecRegistry.js

@@ -0,0 +1,135 @@
+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';
+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,
+};
+/**
+ * A codec registry for both known and portable codecs,
+ */
+export class KnownCodecRegistry {
+    findCodec(name) {
+        return this.#findKnownCodec(name);
+    }
+    findCodecType(name) {
+        const normalizedName = normalizeCodecName(name);
+        const $knownCodec = looseTypeCodecs[normalizedName];
+        if ($knownCodec) {
+            return {
+                name: normalizedName,
+                $codec: $knownCodec,
+                typeIn: `${name}Like`,
+                typeOut: name,
+            };
+        }
+        const $codec = this.findCodec(name);
+        if ($codec.nativeType && $[name]) {
+            return {
+                name: normalizedName,
+                $codec,
+                typeIn: $codec.nativeType,
+                typeOut: $codec.nativeType,
+            };
+        }
+        return {
+            name: normalizedName,
+            $codec,
+            typeIn: name,
+            typeOut: name,
+        };
+    }
+    #findKnownCodec(typeName) {
+        // @ts-ignore
+        const $codec = this.#findKnownWrapperCodec(typeName) || Codecs[normalizeCodecName(typeName)] || $[typeName];
+        if (!$codec) {
+            throw new Error(`Unsupported codec - ${typeName}`);
+        }
+        // This only works with top-level $.deferred codecs
+        // We should make it work for nested $.deferred codecs as well
+        if ($codec.metadata && $codec.metadata[0].name === '$.deferred') {
+            const getShape = $codec.metadata[0].args[0];
+            return $.deferred(() => getShape(this));
+        }
+        return $codec;
+    }
+    #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(this.#findKnownWrapperCodec(inner));
+                }
+                const $inners = inner.split(',').map((one) => this.#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) => this.#findKnownCodec(one.trim()));
+            return $.Tuple(...$inner);
+        }
+    }
+    isKnownType(path) {
+        const joinedPath = Array.isArray(path) ? path.join('::') : path;
+        return KNOWN_PATHS.some((one) => joinedPath.match(one));
+    }
+}

package/helpers/index.d.ts

@@ -0,0 +1 @@
+export * from './KnownCodecRegistry';

package/helpers/index.js

@@ -0,0 +1 @@
+export * from './KnownCodecRegistry';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/codegen",
-  "version": "0.0.1-next.8beb88c3.11+8beb88c",
+  "version": "0.0.1-next.8d06d348.17+8d06d34",
   "description": "Generate types",
   "author": "Thang X. Vu <thang@coongcrafts.io>",
   "homepage": "https://github.com/dedotdev/dedot/tree/main/packages/codegen",
@@ -18,12 +18,12 @@
     "copy": "cp -R ./src/templates ./dist && cp -R ./src/templates ./dist/cjs"
   },
   "dependencies": {
-    "@dedot/codecs": "0.0.1-next.8beb88c3.11+8beb88c",
-    "@dedot/shape": "0.0.1-next.8beb88c3.11+8beb88c",
-    "@dedot/specs": "0.0.1-next.8beb88c3.11+8beb88c",
-    "@dedot/utils": "0.0.1-next.8beb88c3.11+8beb88c",
+    "@dedot/codecs": "0.0.1-next.8d06d348.17+8d06d34",
+    "@dedot/shape": "0.0.1-next.8d06d348.17+8d06d34",
+    "@dedot/specs": "0.0.1-next.8d06d348.17+8d06d34",
+    "@dedot/utils": "0.0.1-next.8d06d348.17+8d06d34",
     "@polkadot/util": "^12.6.2",
-    "dedot": "0.0.1-next.8beb88c3.11+8beb88c",
+    "dedot": "0.0.1-next.8d06d348.17+8d06d34",
     "handlebars": "^4.7.8",
     "prettier": "^3.0.3"
   },
@@ -32,7 +32,7 @@
     "directory": "dist"
   },
   "license": "Apache-2.0",
-  "gitHead": "8beb88c3acd860edb8d37524b4997245e119dad6",
+  "gitHead": "8d06d348e231fd78008acd9122e6ac8ed2794b51",
   "module": "./index.js",
   "types": "./index.d.ts",
   "exports": {

package/types.d.ts

@@ -1,6 +1,14 @@
+import { AnyShape } from '@dedot/shape';
 export type NetworkInfo = {
     chain: string;
     endpoint?: string;
     metadataHex?: string;
     rpcMethods?: string[];
 };
+export type CodecName = `$${string}`;
+export interface CodecType {
+    name: CodecName;
+    $codec: AnyShape;
+    typeIn: string;
+    typeOut: string;
+}