@dedot/codegen 0.0.1-next.f5bf4fc2.1 → 0.0.1-next.fecbe32d.13

package/cjs/generator/ConstsGen.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConstsGen = void 0;
-const util_1 = require("@polkadot/util");
 const utils_1 = require("@dedot/utils");
-const generator_1 = require("../generator");
-const utils_2 = require("./utils");
-class ConstsGen extends generator_1.ApiGen {
+const ApiGen_js_1 = require("./ApiGen.js");
+const utils_js_1 = require("./utils.js");
+class ConstsGen extends ApiGen_js_1.ApiGen {
     generate() {
         const { pallets } = this.metadata;
         this.typesGen.clearCache();
@@ -17,16 +16,16 @@ class ConstsGen extends generator_1.ApiGen {
                 type: this.typesGen.generateType(one.typeId, 1, true),
                 docs: one.docs,
             }));
-            defTypeOut += (0, utils_2.commentBlock)(`Pallet \`${pallet.name}\`'s constants`);
-            defTypeOut += `${(0, util_1.stringLowerFirst)(pallet.name)}: {
-        ${typedConstants.map(({ name, type, docs }) => `${(0, utils_2.commentBlock)(docs)}${name}: ${type}`).join(',\n')}
+            defTypeOut += (0, utils_js_1.commentBlock)(`Pallet \`${pallet.name}\`'s constants`);
+            defTypeOut += `${(0, utils_1.stringCamelCase)(pallet.name)}: {
+        ${typedConstants.map(({ name, type, docs }) => `${(0, utils_js_1.commentBlock)(docs)}${name}: ${type}`).join(',\n')}
           
-        ${(0, utils_2.commentBlock)('Generic pallet constant')}[name: string]: any,
+        ${(0, utils_js_1.commentBlock)('Generic pallet constant')}[name: string]: any,
       },`;
         }
         const importTypes = this.typesGen.typeImports.toImports();
-        const template = (0, utils_2.compileTemplate)('consts.hbs');
-        return (0, utils_2.beautifySourceCode)(template({ importTypes, defTypeOut }));
+        const template = (0, utils_js_1.compileTemplate)('consts.hbs');
+        return (0, utils_js_1.beautifySourceCode)(template({ importTypes, defTypeOut }));
     }
 }
 exports.ConstsGen = ConstsGen;

package/cjs/generator/ErrorsGen.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErrorsGen = void 0;
-const ApiGen_1 = require("./ApiGen");
-const utils_1 = require("./utils");
-const util_1 = require("@polkadot/util");
-const utils_2 = require("@dedot/utils");
-class ErrorsGen extends ApiGen_1.ApiGen {
+const utils_1 = require("@dedot/utils");
+const ApiGen_js_1 = require("./ApiGen.js");
+const utils_js_1 = require("./utils.js");
+class ErrorsGen extends ApiGen_js_1.ApiGen {
     generate() {
         const { pallets } = this.metadata;
         this.typesGen.clearCache();
@@ -17,24 +16,24 @@ class ErrorsGen extends ApiGen_1.ApiGen {
                 continue;
             }
             const errorDefs = this.#getErrorDefs(errorTypeId);
-            defTypeOut += (0, utils_1.commentBlock)(`Pallet \`${pallet.name}\`'s errors`);
-            defTypeOut += `${(0, util_1.stringCamelCase)(pallet.name)}: {
+            defTypeOut += (0, utils_js_1.commentBlock)(`Pallet \`${pallet.name}\`'s errors`);
+            defTypeOut += `${(0, utils_1.stringCamelCase)(pallet.name)}: {
         ${errorDefs
-                .map(({ name, docs }) => `${(0, utils_1.commentBlock)(docs)}${(0, util_1.stringPascalCase)(name)}: GenericPalletError`)
+                .map(({ name, docs }) => `${(0, utils_js_1.commentBlock)(docs)}${(0, utils_1.stringPascalCase)(name)}: GenericPalletError`)
                 .join(',\n')}
           
-        ${(0, utils_1.commentBlock)('Generic pallet error')}[error: string]: GenericPalletError,
+        ${(0, utils_js_1.commentBlock)('Generic pallet error')}[error: string]: GenericPalletError,
       },`;
         }
         const importTypes = this.typesGen.typeImports.toImports();
-        const template = (0, utils_1.compileTemplate)('errors.hbs');
-        return (0, utils_1.beautifySourceCode)(template({ importTypes, defTypeOut }));
+        const template = (0, utils_js_1.compileTemplate)('errors.hbs');
+        return (0, utils_js_1.beautifySourceCode)(template({ importTypes, defTypeOut }));
     }
     #getErrorDefs(errorTypeId) {
         const def = this.metadata.types[errorTypeId];
-        (0, utils_2.assert)(def, `Error def not found for id ${errorTypeId}`);
+        (0, utils_1.assert)(def, `Error def not found for id ${errorTypeId}`);
         const { tag, value } = def.type;
-        (0, utils_2.assert)(tag === 'Enum', `Invalid pallet error type!`);
+        (0, utils_1.assert)(tag === 'Enum', `Invalid pallet error type!`);
         return value.members;
     }
 }

package/cjs/generator/EventsGen.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventsGen = void 0;
-const ApiGen_1 = require("./ApiGen");
-const utils_1 = require("./utils");
-const util_1 = require("@polkadot/util");
-const utils_2 = require("@dedot/utils");
-class EventsGen extends ApiGen_1.ApiGen {
+const utils_1 = require("@dedot/utils");
+const ApiGen_js_1 = require("./ApiGen.js");
+const utils_js_1 = require("./utils.js");
+class EventsGen extends ApiGen_js_1.ApiGen {
     generate() {
         const { pallets } = this.metadata;
         this.typesGen.clearCache();
@@ -18,8 +17,8 @@ class EventsGen extends ApiGen_1.ApiGen {
             }
             const eventDefs = this.#getEventDefs(eventTypeId);
             const flatMembers = eventDefs.every((d) => d.fields.length === 0);
-            defTypeOut += (0, utils_1.commentBlock)(`Pallet \`${pallet.name}\`'s events`);
-            defTypeOut += `${(0, util_1.stringCamelCase)(pallet.name)}: {
+            defTypeOut += (0, utils_js_1.commentBlock)(`Pallet \`${pallet.name}\`'s events`);
+            defTypeOut += `${(0, utils_1.stringCamelCase)(pallet.name)}: {
         ${eventDefs
                 .map((def) => {
                 const genericParts = [`'${pallet.name}'`, `'${def.name}'`];
@@ -32,21 +31,21 @@ class EventsGen extends ApiGen_1.ApiGen {
                 }
                 return { ...def, genericParts };
             })
-                .map(({ name, docs, fields, genericParts }) => `${(0, utils_1.commentBlock)(docs)}${(0, util_1.stringPascalCase)(name)}: GenericPalletEvent<${genericParts.join(', ')}>`)
+                .map(({ name, docs, fields, genericParts }) => `${(0, utils_js_1.commentBlock)(docs)}${(0, utils_1.stringPascalCase)(name)}: GenericPalletEvent<${genericParts.join(', ')}>`)
                 .join(',\n')}
           
-        ${(0, utils_1.commentBlock)('Generic pallet event')}[prop: string]: GenericPalletEvent,
+        ${(0, utils_js_1.commentBlock)('Generic pallet event')}[prop: string]: GenericPalletEvent,
       },`;
         }
         const importTypes = this.typesGen.typeImports.toImports();
-        const template = (0, utils_1.compileTemplate)('events.hbs');
-        return (0, utils_1.beautifySourceCode)(template({ importTypes, defTypeOut }));
+        const template = (0, utils_js_1.compileTemplate)('events.hbs');
+        return (0, utils_js_1.beautifySourceCode)(template({ importTypes, defTypeOut }));
     }
     #getEventDefs(typeId) {
         const def = this.metadata.types[typeId];
-        (0, utils_2.assert)(def, `Event def not found for id ${typeId}`);
+        (0, utils_1.assert)(def, `Event def not found for id ${typeId}`);
         const { tag, value } = def.type;
-        (0, utils_2.assert)(tag === 'Enum', 'Invalid pallet event type!');
+        (0, utils_1.assert)(tag === 'Enum', 'Invalid pallet event type!');
         return value.members;
     }
     #generateMemberDefType(fields) {
@@ -57,7 +56,7 @@ class EventsGen extends ApiGen_1.ApiGen {
             return fields.length === 1
                 ? this.typesGen.generateType(fields[0].typeId, 1, true)
                 : `[${fields
-                    .map(({ typeId, docs }) => `${(0, utils_1.commentBlock)(docs)}${this.typesGen.generateType(typeId, 1, true)}`)
+                    .map(({ typeId, docs }) => `${(0, utils_js_1.commentBlock)(docs)}${this.typesGen.generateType(typeId, 1, true)}`)
                     .join(', ')}]`;
         }
         else {

package/cjs/generator/IndexGen.js

@@ -1,18 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IndexGen = void 0;
-const utils_1 = require("./utils");
-const util_1 = require("@polkadot/util");
+const utils_1 = require("@dedot/utils");
+const utils_js_1 = require("./utils.js");
 class IndexGen {
-    networkInfo;
-    constructor(networkInfo) {
-        this.networkInfo = networkInfo;
+    chain;
+    constructor(chain) {
+        this.chain = chain;
     }
     async generate() {
-        const { chain } = this.networkInfo;
-        const interfaceName = (0, util_1.stringPascalCase)(chain);
-        const template = (0, utils_1.compileTemplate)('index.hbs');
-        return (0, utils_1.beautifySourceCode)(template({ interfaceName }));
+        const interfaceName = (0, utils_1.stringPascalCase)(this.chain);
+        const template = (0, utils_js_1.compileTemplate)('index.hbs');
+        return (0, utils_js_1.beautifySourceCode)(template({ interfaceName }));
     }
 }
 exports.IndexGen = IndexGen;

package/cjs/generator/JsonRpcGen.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonRpcGen = void 0;
+const specs_1 = require("@dedot/specs");
+const index_js_1 = require("../generator/index.js");
+const utils_js_1 = require("./utils.js");
+const HIDDEN_RPCS = [
+    // Ref: https://github.com/paritytech/polkadot-sdk/blob/43415ef58c143b985e09015cd000dbd65f6d3997/substrate/client/rpc-servers/src/lib.rs#L152C9-L158
+    'rpc_methods',
+];
+const ALIAS_RPCS = [
+    // TODO include these into the specs
+    'account_nextIndex',
+    'system_dryRunAt',
+    'state_callAt',
+    'state_getKeysPagedAt',
+    'state_getStorageAt',
+    'state_getStorageHashAt',
+    'state_getStorageSizeAt',
+    'chain_getRuntimeVersion',
+    'chain_getHead',
+    'chain_getFinalisedHead',
+    'childstate_getKeysPagedAt',
+    // Subscription pairs
+    'chain_subscribeRuntimeVersion',
+    'chain_unsubscribeRuntimeVersion',
+    'chain_unsubscribeNewHead',
+    'chain_subscribeNewHead',
+    'subscribe_newHead',
+    'unsubscribe_newHead',
+    'chain_subscribeFinalisedHeads',
+    'chain_unsubscribeFinalisedHeads',
+];
+class JsonRpcGen extends index_js_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('GenericJsonRpcApis');
+        this.typesGen.typeImports.addSpecType('JsonRpcApis');
+        const toExclude = Object.values(specs_1.subscriptionsInfo).flat();
+        const importTypes = this.typesGen.typeImports.toImports();
+        const template = (0, utils_js_1.compileTemplate)('json-rpc.hbs');
+        const jsonRpcMethods = this.rpcMethods
+            .filter((one) => !ALIAS_RPCS.includes(one)) // exclude alias rpcs
+            .filter((one) => !toExclude.includes(one)) // exclude unsubscribe methods
+            .map((one) => `'${one}'`)
+            .join(' | ');
+        return (0, utils_js_1.beautifySourceCode)(template({ importTypes, jsonRpcMethods }));
+    }
+}
+exports.JsonRpcGen = JsonRpcGen;

package/cjs/generator/QueryGen.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryGen = void 0;
-const util_1 = require("@polkadot/util");
 const utils_1 = require("@dedot/utils");
-const generator_1 = require("../generator");
-const utils_2 = require("./utils");
-class QueryGen extends generator_1.ApiGen {
+const ApiGen_js_1 = require("./ApiGen.js");
+const utils_js_1 = require("./utils.js");
+class QueryGen extends ApiGen_js_1.ApiGen {
     generate() {
         const { pallets } = this.metadata;
         this.typesGen.clearCache();
@@ -16,27 +15,35 @@ class QueryGen extends generator_1.ApiGen {
             if (!storage)
                 continue;
             const queries = storage.entries.map((one) => this.#generateEntry(one));
-            const queryDefs = queries.map(({ name, valueType, keyType, docs }) => `${(0, utils_2.commentBlock)(docs)}${name}: GenericStorageQuery<(${keyType}) => ${valueType}>`);
-            defTypeOut += (0, utils_2.commentBlock)(`Pallet \`${pallet.name}\`'s storage queries`);
-            defTypeOut += `${(0, util_1.stringLowerFirst)(pallet.name)}: {
+            const queryDefs = queries.map(({ name, valueType, keyType, docs, keyTypeOut }) => {
+                if (keyTypeOut) {
+                    return `${(0, utils_js_1.commentBlock)(docs)}${name}: GenericStorageQuery<(${keyType}) => ${valueType}, ${keyTypeOut}>`;
+                }
+                else {
+                    return `${(0, utils_js_1.commentBlock)(docs)}${name}: GenericStorageQuery<(${keyType}) => ${valueType}>`;
+                }
+            });
+            defTypeOut += (0, utils_js_1.commentBlock)(`Pallet \`${pallet.name}\`'s storage queries`);
+            defTypeOut += `${(0, utils_1.stringCamelCase)(pallet.name)}: {
         ${queryDefs.join(',\n')}
         
-        ${(0, utils_2.commentBlock)('Generic pallet storage query')}[storage: string]: GenericStorageQuery;
+        ${(0, utils_js_1.commentBlock)('Generic pallet storage query')}[storage: string]: GenericStorageQuery;
       },`;
         }
         const importTypes = this.typesGen.typeImports.toImports();
-        const template = (0, utils_2.compileTemplate)('query.hbs');
-        return (0, utils_2.beautifySourceCode)(template({ importTypes, defTypeOut }));
+        const template = (0, utils_js_1.compileTemplate)('query.hbs');
+        return (0, utils_js_1.beautifySourceCode)(template({ importTypes, defTypeOut }));
     }
     #generateEntry(entry) {
         const { name, type, docs, modifier } = entry;
-        let valueType, keyType;
+        let valueType, keyTypeOut, keyTypeIn;
         if (type.tag === 'Plain') {
             valueType = this.typesGen.generateType(type.value.valueTypeId, 1, true);
         }
         else if (type.tag === 'Map') {
             valueType = this.typesGen.generateType(type.value.valueTypeId, 1, true);
-            keyType = this.typesGen.generateType(type.value.keyTypeId, 1);
+            keyTypeOut = this.typesGen.generateType(type.value.keyTypeId, 1, true);
+            keyTypeIn = this.typesGen.generateType(type.value.keyTypeId, 1);
         }
         else {
             throw Error('Invalid entry type!');
@@ -44,14 +51,15 @@ class QueryGen extends generator_1.ApiGen {
         const isOptional = modifier === 'Optional';
         valueType = `${valueType}${isOptional ? ' | undefined' : ''}`;
         docs.push('\n');
-        if (keyType) {
-            docs.push(`@param {${keyType}} arg`);
+        if (keyTypeIn) {
+            docs.push(`@param {${keyTypeIn}} arg`);
         }
         docs.push(`@param {Callback<${valueType}> =} callback`);
         return {
             name: (0, utils_1.normalizeName)(name),
             valueType,
-            keyType: keyType ? `arg: ${keyType}` : '',
+            keyType: keyTypeIn ? `arg: ${keyTypeIn}` : '',
+            keyTypeOut,
             docs,
         };
     }

package/cjs/generator/RuntimeApisGen.js

@@ -2,15 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RuntimeApisGen = void 0;
 const specs_1 = require("@dedot/specs");
-const utils_1 = require("./utils");
-const utils_2 = require("@dedot/utils");
-const RpcGen_1 = require("./RpcGen");
-const util_1 = require("@polkadot/util");
-class RuntimeApisGen extends RpcGen_1.RpcGen {
+const utils_1 = require("@dedot/utils");
+const ApiGen_js_1 = require("./ApiGen.js");
+const known_codecs_js_1 = require("./known-codecs.js");
+const utils_js_1 = require("./utils.js");
+class RuntimeApisGen extends ApiGen_js_1.ApiGen {
     typesGen;
     runtimeApis;
     constructor(typesGen, runtimeApis) {
-        super(typesGen, []);
+        super(typesGen);
         this.typesGen = typesGen;
         this.runtimeApis = runtimeApis;
     }
@@ -21,19 +21,19 @@ class RuntimeApisGen extends RpcGen_1.RpcGen {
         if (this.metadata.apis.length > 0) {
             this.metadata.apis.forEach((runtimeApi) => {
                 const { name: runtimeApiName, methods } = runtimeApi;
-                runtimeCallsOut += (0, utils_1.commentBlock)(`@runtimeapi: ${runtimeApiName} - ${(0, utils_2.calculateRuntimeApiHash)(runtimeApiName)}`);
-                runtimeCallsOut += `${(0, util_1.stringCamelCase)(runtimeApiName)}: {
+                runtimeCallsOut += (0, utils_js_1.commentBlock)(`@runtimeapi: ${runtimeApiName} - ${(0, utils_1.calcRuntimeApiHash)(runtimeApiName)}`);
+                runtimeCallsOut += `${(0, utils_1.stringCamelCase)(runtimeApiName)}: {
             ${methods.map((method) => this.#generateMethodDef(runtimeApiName, method)).join('\n')} 
               
-            ${(0, utils_1.commentBlock)('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod
+            ${(0, utils_js_1.commentBlock)('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod
         }`;
             });
         }
         else {
             const specs = this.#targetRuntimeApiSpecs();
             specs.forEach(({ methods, runtimeApiName, runtimeApiHash, version }) => {
-                runtimeCallsOut += (0, utils_1.commentBlock)(`@runtimeapi: ${runtimeApiName} - ${runtimeApiHash}`, `@version: ${version}`);
-                runtimeCallsOut += `${(0, util_1.stringCamelCase)(runtimeApiName)}: {
+                runtimeCallsOut += (0, utils_js_1.commentBlock)(`@runtimeapi: ${runtimeApiName} - ${runtimeApiHash}`, `@version: ${version}`);
+                runtimeCallsOut += `${(0, utils_1.stringCamelCase)(runtimeApiName)}: {
             ${Object.keys(methods)
                     .map((methodName) => this.#generateMethodDefFromSpec({
                     ...methods[methodName],
@@ -42,13 +42,13 @@ class RuntimeApisGen extends RpcGen_1.RpcGen {
                 }))
                     .join('\n')} 
               
-            ${(0, utils_1.commentBlock)('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod
+            ${(0, utils_js_1.commentBlock)('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod
           }`;
             });
         }
         const importTypes = this.typesGen.typeImports.toImports();
-        const template = (0, utils_1.compileTemplate)('runtime.hbs');
-        return (0, utils_1.beautifySourceCode)(template({ importTypes, runtimeCallsOut }));
+        const template = (0, utils_js_1.compileTemplate)('runtime.hbs');
+        return (0, utils_js_1.beautifySourceCode)(template({ importTypes, runtimeCallsOut }));
     }
     #isOptionalType(type) {
         return type.startsWith('Option<') || type.endsWith('| undefined');
@@ -58,27 +58,27 @@ class RuntimeApisGen extends RpcGen_1.RpcGen {
     }
     #generateMethodDefFromSpec(spec) {
         const { docs = [], params, type, runtimeApiName, methodName } = spec;
-        const callName = `${runtimeApiName}_${(0, utils_2.stringSnakeCase)(methodName)}`;
+        const callName = `${runtimeApiName}_${(0, utils_1.stringSnakeCase)(methodName)}`;
         const defaultDocs = [`@callname: ${callName}`];
-        this.addTypeImport(type, false);
-        params.forEach(({ type }) => this.addTypeImport(type));
+        this.#addTypeImport(type, false);
+        params.forEach(({ type }) => this.#addTypeImport(type));
         const typedParams = params.map((param, idx) => ({
             ...param,
             isOptional: this.#isOptionalParam(params, param.type, idx),
-            plainType: this.getGeneratedTypeName(param.type),
+            plainType: this.#getGeneratedTypeName(param.type),
         }));
         const paramsOut = typedParams
-            .map(({ name, isOptional, plainType }) => `${(0, util_1.stringCamelCase)(name)}${isOptional ? '?' : ''}: ${plainType}`)
+            .map(({ name, isOptional, plainType }) => `${(0, utils_1.stringCamelCase)(name)}${isOptional ? '?' : ''}: ${plainType}`)
             .join(', ');
-        const typeOut = this.getGeneratedTypeName(type, false);
-        return `${(0, utils_1.commentBlock)(docs, '\n', defaultDocs, typedParams.map(({ plainType, name }) => `@param {${plainType}} ${name}`))}${methodName}: GenericRuntimeApiMethod<(${paramsOut}) => Promise<${typeOut}>>`;
+        const typeOut = this.#getGeneratedTypeName(type, false);
+        return `${(0, utils_js_1.commentBlock)(docs, '\n', defaultDocs, typedParams.map(({ plainType, name }) => `@param {${plainType}} ${name}`))}${methodName}: GenericRuntimeApiMethod<(${paramsOut}) => Promise<${typeOut}>>`;
     }
     #generateMethodDef(runtimeApiName, methodDef) {
         const { name: methodName, inputs, output, docs } = methodDef;
-        const callName = `${runtimeApiName}_${(0, utils_2.stringSnakeCase)(methodName)}`;
+        const callName = `${runtimeApiName}_${(0, utils_1.stringSnakeCase)(methodName)}`;
         const defaultDocs = [`@callname: ${callName}`];
         const typeOut = this.typesGen.generateType(output, 1, true);
-        this.addTypeImport(typeOut, false);
+        this.#addTypeImport(typeOut, false);
         const typedInputs = inputs
             .map((input, idx) => ({
             ...input,
@@ -88,14 +88,14 @@ class RuntimeApisGen extends RpcGen_1.RpcGen {
             ...input,
             isOptional: this.#isOptionalParam(inputs, input.type, idx),
         }));
-        this.addTypeImport(typedInputs.map((t) => t.type));
+        this.#addTypeImport(typedInputs.map((t) => t.type));
         const paramsOut = typedInputs
-            .map(({ name, type, isOptional }) => `${(0, util_1.stringCamelCase)(name)}${isOptional ? '?' : ''}: ${type}`)
+            .map(({ name, type, isOptional }) => `${(0, utils_1.stringCamelCase)(name)}${isOptional ? '?' : ''}: ${type}`)
             .join(', ');
-        return `${(0, utils_1.commentBlock)(docs, '\n', defaultDocs, typedInputs.map(({ type, name }) => `@param {${type}} ${name}`))}${(0, util_1.stringCamelCase)(methodName)}: GenericRuntimeApiMethod<(${paramsOut}) => Promise<${typeOut}>>`;
+        return `${(0, utils_js_1.commentBlock)(docs, '\n', defaultDocs, typedInputs.map(({ type, name }) => `@param {${type}} ${name}`))}${(0, utils_1.stringCamelCase)(methodName)}: GenericRuntimeApiMethod<(${paramsOut}) => Promise<${typeOut}>>`;
     }
     #targetRuntimeApiSpecs() {
-        const specs = this.runtimeApis.map(([runtimeApiHash, version]) => {
+        const specs = Object.entries(this.runtimeApis).map(([runtimeApiHash, version]) => {
             const runtimeApiSpec = this.#findRuntimeApiSpec(runtimeApiHash, version);
             if (!runtimeApiSpec)
                 return;
@@ -112,8 +112,82 @@ class RuntimeApisGen extends RpcGen_1.RpcGen {
         }, []);
     }
     #findRuntimeApiSpec = (runtimeApiHash, version) => {
-        const runtimeApiName = (0, specs_1.getRuntimeApiNames)().find((one) => (0, utils_2.calculateRuntimeApiHash)(one) === runtimeApiHash);
+        const runtimeApiName = (0, specs_1.getRuntimeApiNames)().find((one) => (0, utils_1.calcRuntimeApiHash)(one) === runtimeApiHash);
         return (0, specs_1.getRuntimeApiSpecs)().find((one) => one.runtimeApiName === runtimeApiName && one.version === version);
     };
+    // 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_js_1.isNativeType)(type)) {
+            return;
+        }
+        // Handle generic wrapper types
+        const matchArray = type.match(utils_js_1.WRAPPER_TYPE_REGEX);
+        if (matchArray) {
+            const [_, $1, $2] = matchArray;
+            this.#addTypeImport($1, toTypeIn);
+            if ($2.match(utils_js_1.WRAPPER_TYPE_REGEX) || $2.match(utils_js_1.TUPLE_TYPE_REGEX)) {
+                this.#addTypeImport($2, toTypeIn);
+            }
+            else {
+                this.#addTypeImport($2.split(','), toTypeIn);
+            }
+            return;
+        }
+        // Check tuple type
+        if (type.match(utils_js_1.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_js_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_js_1.WRAPPER_TYPE_REGEX);
+            if (matchArray) {
+                const [_, $1, $2] = matchArray;
+                const wrapperTypeName = this.#getCodecType($1, toTypeIn);
+                if ($2.match(utils_js_1.WRAPPER_TYPE_REGEX) || $2.match(utils_js_1.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_js_1.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 } = (0, known_codecs_js_1.findKnownCodecType)(type);
+        return toTypeIn ? typeIn : typeOut;
+    }
 }
 exports.RuntimeApisGen = RuntimeApisGen;

package/cjs/generator/TxGen.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TxGen = void 0;
-const generator_1 = require("../generator");
-const util_1 = require("@polkadot/util");
-const utils_1 = require("./utils");
-class TxGen extends generator_1.ApiGen {
+const utils_1 = require("@dedot/utils");
+const index_js_1 = require("../generator/index.js");
+const utils_js_1 = require("./utils.js");
+class TxGen extends index_js_1.ApiGen {
     generate() {
         const { pallets, types } = this.metadata;
         this.typesGen.clearCache();
@@ -26,9 +26,9 @@ class TxGen extends generator_1.ApiGen {
             const isFlatEnum = type.value.members.every((m) => m.fields.length === 0);
             const typedTxs = type.value.members
                 .map((one) => ({
-                functionName: (0, util_1.stringCamelCase)(one.name),
+                functionName: (0, utils_1.stringCamelCase)(one.name),
                 params: one.fields.map((f) => ({
-                    name: (0, util_1.stringCamelCase)(f.name),
+                    name: (0, utils_1.stringCamelCase)(f.name),
                     normalizedName: this.#normalizeParamName(f.name),
                     type: this.typesGen.generateType(f.typeId, 1),
                     docs: f.docs,
@@ -38,16 +38,16 @@ class TxGen extends generator_1.ApiGen {
                 .map((f) => {
                 return {
                     ...f,
-                    callInput: this.#generateCallInput((0, util_1.stringPascalCase)(pallet.name), (0, util_1.stringPascalCase)(f.functionName), !isFlatEnum ? f.params.map((p) => `${p.name}: ${p.type}`) : undefined),
+                    callInput: this.#generateCallInput((0, utils_1.stringPascalCase)(pallet.name), (0, utils_1.stringPascalCase)(f.functionName), !isFlatEnum ? f.params.map((p) => `${p.name}: ${p.type}`) : undefined),
                 };
             });
-            txDefsOut += (0, utils_1.commentBlock)(`Pallet \`${pallet.name}\`'s transaction calls`);
-            txDefsOut += `${(0, util_1.stringCamelCase)(pallet.name)}: {
+            txDefsOut += (0, utils_js_1.commentBlock)(`Pallet \`${pallet.name}\`'s transaction calls`);
+            txDefsOut += `${(0, utils_1.stringCamelCase)(pallet.name)}: {
           ${typedTxs
-                .map(({ functionName, params, docs, callInput }) => `${(0, utils_1.commentBlock)(docs, '\n', params.map((p) => `@param {${p.type}} ${p.normalizedName} ${p.docs}`))}${functionName}: GenericTxCall<(${params.map((p) => `${p.normalizedName}: ${p.type}`).join(', ')}) => ChainSubmittableExtrinsic<${callInput}>>`)
+                .map(({ functionName, params, docs, callInput }) => `${(0, utils_js_1.commentBlock)(docs, '\n', params.map((p) => `@param {${p.type}} ${p.normalizedName} ${p.docs}`))}${functionName}: GenericTxCall<(${params.map((p) => `${p.normalizedName}: ${p.type}`).join(', ')}) => ChainSubmittableExtrinsic<${callInput}>>`)
                 .join(',\n')}
             
-          ${(0, utils_1.commentBlock)('Generic pallet tx call')}[callName: string]: GenericTxCall<TxCall>,
+          ${(0, utils_js_1.commentBlock)('Generic pallet tx call')}[callName: string]: GenericTxCall<TxCall>,
         },`;
         }
         const importTypes = this.typesGen.typeImports.toImports();
@@ -59,12 +59,12 @@ class TxGen extends generator_1.ApiGen {
         
     export type TxCall = (...args: any[]) => ChainSubmittableExtrinsic;    
 `;
-        const template = (0, utils_1.compileTemplate)('tx.hbs');
-        return (0, utils_1.beautifySourceCode)(template({ importTypes, defTypes, txDefsOut }));
+        const template = (0, utils_js_1.compileTemplate)('tx.hbs');
+        return (0, utils_js_1.beautifySourceCode)(template({ importTypes, defTypes, txDefsOut }));
     }
     #normalizeParamName(name) {
-        name = (0, util_1.stringCamelCase)(name);
-        return (0, utils_1.isReservedWord)(name) ? `${name}_` : name;
+        name = (0, utils_1.stringCamelCase)(name);
+        return (0, utils_js_1.isReservedWord)(name) ? `${name}_` : name;
     }
     #generateCallInput(palletName, callName, params) {
         if (!params) {

package/cjs/generator/TypeImports.js

@@ -8,30 +8,35 @@ class TypeImports {
     codecTypes;
     // Known types that're not codecs or chain/portable types defined in @dedot/types
     knownTypes;
+    specTypes;
     // External types to define explicitly
     outTypes;
     constructor() {
         this.portableTypes = new Set();
         this.codecTypes = new Set();
         this.knownTypes = new Set();
+        this.specTypes = new Set();
         this.outTypes = new Set();
     }
     clear() {
         this.portableTypes.clear();
         this.codecTypes.clear();
         this.knownTypes.clear();
+        this.specTypes.clear();
         this.outTypes.clear();
     }
     toImports(...excludeModules) {
         // TODO generate outTypes!
         const toImports = [
             [this.knownTypes, '@dedot/types'],
+            [this.specTypes, '@dedot/specs'],
             [this.codecTypes, '@dedot/codecs'],
             [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) {
@@ -49,6 +54,9 @@ class TypeImports {
     addKnownType(...types) {
         types.forEach((one) => this.knownTypes.add(one));
     }
+    addSpecType(...types) {
+        types.forEach((one) => this.specTypes.add(one));
+    }
     addOutType(...types) {
         types.forEach((one) => this.outTypes.add(one));
     }