@dedot/codegen 0.0.1-next.8d06d348.17 → 0.0.1-next.8f4b2c24.6

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

@@ -8,3 +8,8 @@ export declare const compileTemplate: (templateFileName: string) => HandlebarsTe
  * @param word
  */
 export declare const isReservedWord: (word: string) => boolean;
+/**
+ * Check if a type is native JS/TS type
+ * @param type
+ */
+export declare const isNativeType: (type: string) => boolean;

package/generator/utils.js

@@ -33,3 +33,31 @@ const TS_RESERVED_WORDS = ['new', 'class'];
  * @param word
  */
 export const isReservedWord = (word) => TS_RESERVED_WORDS.includes(word);
+const TS_PRIMITIVE_TYPES = [
+    'void',
+    'undefined',
+    'null',
+    'number',
+    'boolean',
+    'bigint',
+    'Map',
+    'Set',
+    'string',
+    'any',
+    'Array',
+    'Record',
+];
+/**
+ * Check if a type is native JS/TS type
+ * @param type
+ */
+export const isNativeType = (type) => {
+    return TS_PRIMITIVE_TYPES.some((one) => {
+        if (typeof one === 'string') {
+            return one === type;
+        }
+        else {
+            return type.match(one);
+        }
+    });
+};

package/index.d.ts

@@ -1,4 +1,3 @@
 import { MetadataLatest } from '@dedot/codecs';
-import { NetworkInfo } from './types';
-export declare function generateTypesFromChain(network: NetworkInfo, endpoint: string, outDir: string): Promise<void>;
-export declare function generateTypes(network: NetworkInfo, metadata: MetadataLatest, rpcMethods: string[], runtimeApis: any[], outDir?: string): Promise<void>;
+export declare function generateTypesFromEndpoint(chain: string, endpoint: string, outDir?: string, extension?: string): Promise<void>;
+export declare function generateTypes(chain: string, metadata: MetadataLatest, rpcMethods: string[], runtimeApis: Record<string, number>, outDir?: string, extension?: string): Promise<void>;

package/index.js

@@ -1,37 +1,37 @@
 import { Dedot } from 'dedot';
 import * as fs from 'fs';
 import * as path from 'path';
-import { ConstsGen, ErrorsGen, EventsGen, IndexGen, QueryGen, RpcGen, RuntimeApisGen, TxGen, TypesGen, } from './generator';
-import { stringCamelCase } from '@polkadot/util';
-export async function generateTypesFromChain(network, endpoint, outDir) {
-    const api = await Dedot.create(endpoint);
-    const { methods } = await api.rpc.rpc.methods();
-    const apis = api.runtimeVersion?.apis || [];
-    if (!network.chain) {
-        network.chain = stringCamelCase(api.runtimeVersion?.specName || api.runtimeChain || 'local');
+import { ConstsGen, ErrorsGen, EventsGen, IndexGen, QueryGen, JsonRpcGen, RuntimeApisGen, TxGen, TypesGen, } from './generator/index.js';
+import { stringCamelCase } from '@dedot/utils';
+export async function generateTypesFromEndpoint(chain, endpoint, outDir, extension = 'd.ts') {
+    const api = await Dedot.new(endpoint);
+    const { methods } = await api.rpc.rpc_methods();
+    const apis = api.runtimeVersion.apis || {};
+    if (!chain) {
+        chain = stringCamelCase(api.runtimeVersion.specName || api.runtimeChain || 'local');
     }
-    await generateTypes(network, api.metadataLatest, methods, apis, outDir);
+    await generateTypes(chain, api.metadata.latest, methods, apis, outDir, extension);
     await api.disconnect();
 }
-export async function generateTypes(network, metadata, rpcMethods, runtimeApis, outDir = '.') {
-    const dirPath = path.resolve(outDir, network.chain);
-    const defTypesFileName = path.join(dirPath, `types.d.ts`);
-    const constsTypesFileName = path.join(dirPath, `consts.d.ts`);
-    const queryTypesFileName = path.join(dirPath, `query.d.ts`);
-    const rpcCallsFileName = path.join(dirPath, `rpc.d.ts`);
-    const indexFileName = path.join(dirPath, `index.d.ts`);
-    const errorsFileName = path.join(dirPath, `errors.d.ts`);
-    const eventsFileName = path.join(dirPath, `events.d.ts`);
-    const runtimeApisFileName = path.join(dirPath, `runtime.d.ts`);
-    const txFileName = path.join(dirPath, `tx.d.ts`);
+export async function generateTypes(chain, metadata, rpcMethods, runtimeApis, outDir = '.', extension = 'd.ts') {
+    const dirPath = path.resolve(outDir, chain);
+    const defTypesFileName = path.join(dirPath, `types.${extension}`);
+    const constsTypesFileName = path.join(dirPath, `consts.${extension}`);
+    const queryTypesFileName = path.join(dirPath, `query.${extension}`);
+    const jsonRpcFileName = path.join(dirPath, `json-rpc.${extension}`);
+    const indexFileName = path.join(dirPath, `index.${extension}`);
+    const errorsFileName = path.join(dirPath, `errors.${extension}`);
+    const eventsFileName = path.join(dirPath, `events.${extension}`);
+    const runtimeApisFileName = path.join(dirPath, `runtime.${extension}`);
+    const txFileName = path.join(dirPath, `tx.${extension}`);
     if (!fs.existsSync(dirPath)) {
         fs.mkdirSync(dirPath, { recursive: true });
     }
     const typesGen = new TypesGen(metadata);
     const constsGen = new ConstsGen(typesGen);
     const queryGen = new QueryGen(typesGen);
-    const rpcGen = new RpcGen(typesGen, rpcMethods);
-    const indexGen = new IndexGen(network);
+    const jsonRpcGen = new JsonRpcGen(typesGen, rpcMethods);
+    const indexGen = new IndexGen(chain);
     const errorsGen = new ErrorsGen(typesGen);
     const eventsGen = new EventsGen(typesGen);
     const runtimeApisGen = new RuntimeApisGen(typesGen, runtimeApis);
@@ -39,7 +39,7 @@ export async function generateTypes(network, metadata, rpcMethods, runtimeApis,
     fs.writeFileSync(defTypesFileName, await typesGen.generate());
     fs.writeFileSync(errorsFileName, await errorsGen.generate());
     fs.writeFileSync(eventsFileName, await eventsGen.generate());
-    fs.writeFileSync(rpcCallsFileName, await rpcGen.generate());
+    fs.writeFileSync(jsonRpcFileName, await jsonRpcGen.generate());
     fs.writeFileSync(queryTypesFileName, await queryGen.generate());
     fs.writeFileSync(constsTypesFileName, await constsGen.generate());
     fs.writeFileSync(txFileName, await txGen.generate());

package/package.json

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

package/templates/index.hbs

@@ -3,7 +3,7 @@
 import { GenericSubstrateApi } from '@dedot/types';
 import { ChainConsts } from './consts';
 import { ChainStorage } from './query';
-import { RpcCalls } from './rpc';
+import { ChainJsonRpcApis } from './json-rpc';
 import { ChainErrors } from './errors';
 import { ChainEvents } from './events';
 import { RuntimeApis } from './runtime';
@@ -12,7 +12,7 @@ import { ChainTx } from './tx';
 export * from './types';
 
 export interface {{{interfaceName}}}Api extends GenericSubstrateApi {
-  rpc: RpcCalls;
+  rpc: ChainJsonRpcApis;
   consts: ChainConsts;
   query: ChainStorage;
   errors: ChainErrors;

package/templates/json-rpc.hbs

@@ -0,0 +1,5 @@
+// Generated by @dedot/codegen
+
+{{{ importTypes }}}
+
+export type ChainJsonRpcApis = Pick<JsonRpcApis, {{{jsonRpcMethods}}}> & GenericJsonRpcApis;

package/cjs/genSupportedChainTypes.js

@@ -1,79 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_1 = require("./index");
-const static_substrate_1 = require("@polkadot/types-support/metadata/static-substrate");
-const substrate_hex_1 = __importDefault(require("@polkadot/types-support/metadata/v15/substrate-hex"));
-const codecs_1 = require("@dedot/codecs");
-const dedot_1 = require("dedot");
-const NETWORKS = [
-    {
-        chain: 'substrate',
-        metadataHex: substrate_hex_1.default,
-        rpcMethods: static_substrate_1.rpc.methods,
-    },
-    {
-        chain: 'polkadot',
-        endpoint: 'wss://rpc.polkadot.io',
-    },
-    {
-        chain: 'kusama',
-        endpoint: 'wss://kusama-rpc.polkadot.io',
-    },
-    {
-        chain: 'astar',
-        endpoint: 'wss://rpc.astar.network',
-    },
-    {
-        chain: 'moonbeam',
-        endpoint: 'wss://moonbeam.api.onfinality.io/public-ws',
-    },
-    {
-        chain: 'polkadotAssetHub',
-        endpoint: 'wss://polkadot-asset-hub-rpc.polkadot.io/',
-    },
-    {
-        chain: 'kusamaAssetHub',
-        endpoint: 'wss://kusama-asset-hub-rpc.polkadot.io/',
-    },
-    {
-        chain: 'rococoAssetHub',
-        endpoint: 'wss://rococo-asset-hub-rpc.polkadot.io/',
-    },
-    {
-        chain: 'aleph',
-        endpoint: 'wss://aleph-zero.api.onfinality.io/public-ws',
-    },
-    {
-        chain: 'westendAssetHub',
-        endpoint: 'wss://westend-asset-hub-rpc.polkadot.io',
-    },
-];
-const OUT_DIR = 'packages/chaintypes/src';
-async function run() {
-    for (const network of NETWORKS) {
-        const { chain, endpoint, metadataHex, rpcMethods } = network;
-        if (endpoint) {
-            console.log(`Generate types for ${chain} via endpoint ${endpoint}`);
-            await (0, index_1.generateTypesFromChain)(network, endpoint, OUT_DIR);
-        }
-        else if (metadataHex && rpcMethods) {
-            console.log(`Generate types for ${chain} via raw data`);
-            const metadata = codecs_1.$Metadata.tryDecode(metadataHex);
-            const runtimeVersion = getRuntimeVersion(metadata);
-            await (0, index_1.generateTypes)(network, metadata.latest, rpcMethods, runtimeVersion.apis, OUT_DIR);
-        }
-    }
-    console.log('DONE!');
-}
-const getRuntimeVersion = (metadata) => {
-    const registry = new codecs_1.CodecRegistry(metadata.latest);
-    const executor = new dedot_1.ConstantExecutor({
-        registry,
-        metadataLatest: metadata.latest,
-    });
-    return executor.execute('system', 'version');
-};
-run().catch(console.log);

package/cjs/generator/RpcGen.js

@@ -1,175 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RpcGen = void 0;
-const specs_1 = require("@dedot/specs");
-const utils_1 = require("@dedot/utils");
-const generator_1 = require("../generator");
-const utils_2 = require("./utils");
-const HIDDEN_RPCS = [
-    // Ref: https://github.com/paritytech/polkadot-sdk/blob/43415ef58c143b985e09015cd000dbd65f6d3997/substrate/client/rpc-servers/src/lib.rs#L152C9-L158
-    'rpc_methods',
-];
-class RpcGen extends generator_1.ApiGen {
-    typesGen;
-    rpcMethods;
-    constructor(typesGen, rpcMethods) {
-        super(typesGen);
-        this.typesGen = typesGen;
-        this.rpcMethods = rpcMethods;
-        HIDDEN_RPCS.filter((one) => !rpcMethods.includes(one)).forEach((one) => rpcMethods.push(one));
-        rpcMethods.sort();
-    }
-    generate() {
-        this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericRpcCalls', 'Unsub', 'Callback', 'GenericRpcCall');
-        const specsByModule = this.rpcMethods
-            .filter((one) => !(0, specs_1.findAliasRpcSpec)(one)) // we'll ignore  alias rpc for now if defined in the specs! TODO should we generate alias rpc as well?
-            .filter((one) => !(0, specs_1.isUnsubscribeMethod)(one)) // we'll ignore unsubscribe method as well
-            .map((one) => {
-            const spec = (0, specs_1.findRpcSpec)(one);
-            if (spec) {
-                return spec;
-            }
-            const [module, ...methodParts] = one.split('_');
-            const method = methodParts.join('_');
-            return {
-                params: [],
-                type: 'GenericRpcCall',
-                module,
-                method,
-            };
-        })
-            .reduce((o, spec) => {
-            const { module, method } = spec;
-            // ignore if rpc name does not confront with the general convention
-            if (!module || !method) {
-                return o;
-            }
-            return {
-                ...o,
-                [module]: o[module] ? [...o[module], spec] : [spec],
-            };
-        }, {});
-        let rpcCallsOut = '';
-        Object.keys(specsByModule).forEach((module) => {
-            const specs = specsByModule[module];
-            // TODO add alias info to docs block!
-            rpcCallsOut += `${module}: {
-      ${specs.map((spec) => this.#generateMethodDef(spec)).join(',\n')},
-
-      [method: string]: GenericRpcCall,
-    },`;
-        });
-        // TODO include & define external types
-        const importTypes = this.typesGen.typeImports.toImports();
-        const template = (0, utils_2.compileTemplate)('rpc.hbs');
-        return (0, utils_2.beautifySourceCode)(template({ importTypes, rpcCallsOut }));
-    }
-    #generateMethodDef(spec) {
-        const { name, type, module, method, docs = [], params, pubsub, deprecated } = spec;
-        const rpcName = name || `${module}_${method}`;
-        let defaultDocs = [`@rpcname: ${rpcName}`];
-        if (deprecated) {
-            defaultDocs.push(`@deprecated: ${deprecated}`);
-        }
-        if (type === 'GenericRpcCall' && params.length === 0) {
-            return `${(0, utils_2.commentBlock)(defaultDocs)}${method}: GenericRpcCall`;
-        }
-        this.addTypeImport(type, false);
-        params.forEach(({ type, isScale }) => {
-            this.addTypeImport(type, !!isScale);
-        });
-        const typedParams = params.map((param) => ({
-            ...param,
-            plainType: this.getGeneratedTypeName(param.type, !!param.isScale),
-        }));
-        const isSubscription = !!pubsub;
-        const paramsOut = typedParams.map(({ name, type, isOptional, isScale, plainType }) => `${name}${isOptional ? '?' : ''}: ${plainType}`);
-        const paramsDoc = typedParams.map(({ name, plainType }) => `@param {${plainType}} ${name}`);
-        const typeOut = this.getGeneratedTypeName(type, false);
-        if (isSubscription) {
-            defaultDocs.shift();
-            defaultDocs.unshift(`@pubsub: ${pubsub?.join(', ')}`);
-            paramsOut.push(`callback: Callback<${typeOut}>`);
-            return `${(0, utils_2.commentBlock)(docs, '\n', defaultDocs, paramsDoc)}${method}: GenericRpcCall<(${paramsOut.join(', ')}) => Promise<Unsub>>`;
-        }
-        else {
-            return `${(0, utils_2.commentBlock)(docs, '\n', defaultDocs, paramsDoc)}${method}: GenericRpcCall<(${paramsOut.join(', ')}) => Promise<${typeOut}>>`;
-        }
-    }
-    // TODO check typeIn, typeOut if param type, or rpc type isScale
-    addTypeImport(type, toTypeIn = true) {
-        if (Array.isArray(type)) {
-            type.forEach((one) => this.addTypeImport(one, toTypeIn));
-            return;
-        }
-        type = type.trim();
-        if ((0, utils_1.isNativeType)(type)) {
-            return;
-        }
-        // Handle generic wrapper types
-        const matchArray = type.match(utils_2.WRAPPER_TYPE_REGEX);
-        if (matchArray) {
-            const [_, $1, $2] = matchArray;
-            this.addTypeImport($1, toTypeIn);
-            if ($2.match(utils_2.WRAPPER_TYPE_REGEX) || $2.match(utils_2.TUPLE_TYPE_REGEX)) {
-                this.addTypeImport($2, toTypeIn);
-            }
-            else {
-                this.addTypeImport($2.split(','), toTypeIn);
-            }
-            return;
-        }
-        // Check tuple type
-        if (type.match(utils_2.TUPLE_TYPE_REGEX)) {
-            this.addTypeImport(type.slice(1, -1).split(','), toTypeIn);
-            return;
-        }
-        if (type.includes(' | ')) {
-            this.addTypeImport(type.split(' | ').map((one) => one.trim()), toTypeIn);
-            return;
-        }
-        try {
-            const codecType = this.#getCodecType(type, toTypeIn);
-            if ((0, utils_1.isNativeType)(codecType))
-                return;
-            this.typesGen.typeImports.addCodecType(codecType);
-            return;
-        }
-        catch (e) { }
-        this.typesGen.addTypeImport(type);
-    }
-    getGeneratedTypeName(type, toTypeIn = true) {
-        try {
-            const matchArray = type.match(utils_2.WRAPPER_TYPE_REGEX);
-            if (matchArray) {
-                const [_, $1, $2] = matchArray;
-                const wrapperTypeName = this.#getCodecType($1, toTypeIn);
-                if ($2.match(utils_2.WRAPPER_TYPE_REGEX) || $2.match(utils_2.TUPLE_TYPE_REGEX)) {
-                    return `${wrapperTypeName}<${this.getGeneratedTypeName($2, toTypeIn)}>`;
-                }
-                const innerTypeNames = $2
-                    .split(',')
-                    .map((one) => this.getGeneratedTypeName(one.trim(), toTypeIn))
-                    .join(', ');
-                return `${wrapperTypeName}<${innerTypeNames}>`;
-            }
-            else if (type.match(utils_2.TUPLE_TYPE_REGEX)) {
-                const innerTypeNames = type
-                    .slice(1, -1)
-                    .split(',')
-                    .map((one) => this.getGeneratedTypeName(one.trim(), toTypeIn))
-                    .join(', ');
-                return `[${innerTypeNames}]`;
-            }
-            return this.#getCodecType(type, toTypeIn);
-        }
-        catch (e) { }
-        return type;
-    }
-    #getCodecType(type, toTypeIn = true) {
-        const { typeIn, typeOut } = this.typesGen.knownCodecRegistry.findCodecType(type);
-        return toTypeIn ? typeIn : typeOut;
-    }
-}
-exports.RpcGen = RpcGen;

package/cjs/helpers/index.js

@@ -1,17 +0,0 @@
-"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/cjs/packageInfo.js

@@ -1,5 +0,0 @@
-"use strict";
-// 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' };

package/cjs/templates/rpc.hbs

@@ -1,7 +0,0 @@
-// Generated by @dedot/codegen
-
-{{{ importTypes }}}
-
-export interface RpcCalls extends GenericRpcCalls {
-  {{{rpcCallsOut}}}
-}

package/cjs/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/genSupportedChainTypes.d.ts

@@ -1 +0,0 @@
-export {};

package/genSupportedChainTypes.js

@@ -1,74 +0,0 @@
-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 { ConstantExecutor } from 'dedot';
-const NETWORKS = [
-    {
-        chain: 'substrate',
-        metadataHex: staticSubstrate,
-        rpcMethods: rpc.methods,
-    },
-    {
-        chain: 'polkadot',
-        endpoint: 'wss://rpc.polkadot.io',
-    },
-    {
-        chain: 'kusama',
-        endpoint: 'wss://kusama-rpc.polkadot.io',
-    },
-    {
-        chain: 'astar',
-        endpoint: 'wss://rpc.astar.network',
-    },
-    {
-        chain: 'moonbeam',
-        endpoint: 'wss://moonbeam.api.onfinality.io/public-ws',
-    },
-    {
-        chain: 'polkadotAssetHub',
-        endpoint: 'wss://polkadot-asset-hub-rpc.polkadot.io/',
-    },
-    {
-        chain: 'kusamaAssetHub',
-        endpoint: 'wss://kusama-asset-hub-rpc.polkadot.io/',
-    },
-    {
-        chain: 'rococoAssetHub',
-        endpoint: 'wss://rococo-asset-hub-rpc.polkadot.io/',
-    },
-    {
-        chain: 'aleph',
-        endpoint: 'wss://aleph-zero.api.onfinality.io/public-ws',
-    },
-    {
-        chain: 'westendAssetHub',
-        endpoint: 'wss://westend-asset-hub-rpc.polkadot.io',
-    },
-];
-const OUT_DIR = 'packages/chaintypes/src';
-async function run() {
-    for (const network of NETWORKS) {
-        const { chain, endpoint, metadataHex, rpcMethods } = network;
-        if (endpoint) {
-            console.log(`Generate types for ${chain} via endpoint ${endpoint}`);
-            await generateTypesFromChain(network, endpoint, OUT_DIR);
-        }
-        else if (metadataHex && rpcMethods) {
-            console.log(`Generate types for ${chain} via raw data`);
-            const metadata = $Metadata.tryDecode(metadataHex);
-            const runtimeVersion = getRuntimeVersion(metadata);
-            await generateTypes(network, metadata.latest, rpcMethods, runtimeVersion.apis, OUT_DIR);
-        }
-    }
-    console.log('DONE!');
-}
-const getRuntimeVersion = (metadata) => {
-    const registry = new CodecRegistry(metadata.latest);
-    const executor = new ConstantExecutor({
-        registry,
-        metadataLatest: metadata.latest,
-    });
-    return executor.execute('system', 'version');
-};
-run().catch(console.log);