@dedot/codegen 0.14.1 → 0.15.1

package/chaintypes/generator/ApiGen.d.ts

@@ -154,7 +154,7 @@ export declare abstract class ApiGen {
                 docs: string[];
             }[];
             viewFunctions: {
-                id: readonly [number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number];
+                id: Uint8Array;
                 name: string;
                 inputs: {
                     name: string;
@@ -191,8 +191,8 @@ export declare abstract class ApiGen {
         extrinsic: {
             versions: number[];
             addressTypeId: number;
-            signatureTypeId: number;
             callTypeId: number;
+            signatureTypeId: number;
             signedExtensionsByVersion: ReadonlyMap<number, number[]>;
             signedExtensions: {
                 ident: string;

package/chaintypes/generator/ConstsGen.js

@@ -1,5 +1,6 @@
 import { normalizeName, stringCamelCase } from '@dedot/utils';
 import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
+import { getDeprecationComment } from '../../utils.js';
 import { ApiGen } from './ApiGen.js';
 export class ConstsGen extends ApiGen {
     generate(useSubPaths = false) {
@@ -8,11 +9,18 @@ export class ConstsGen extends ApiGen {
         this.typesGen.typeImports.addKnownType('GenericChainConsts', 'RpcVersion');
         let defTypeOut = '';
         for (let pallet of pallets) {
-            const typedConstants = pallet.constants.map((one) => ({
-                name: normalizeName(one.name),
-                type: this.typesGen.generateType(one.typeId, 1, true),
-                docs: one.docs,
-            }));
+            const typedConstants = pallet.constants.map((one) => {
+                const { deprecationInfo, docs } = one;
+                const deprecationComments = getDeprecationComment(deprecationInfo);
+                if (deprecationComments.length > 0) {
+                    docs.push('\n', ...deprecationComments);
+                }
+                return {
+                    name: normalizeName(one.name),
+                    type: this.typesGen.generateType(one.typeId, 1, true),
+                    docs,
+                };
+            });
             defTypeOut += commentBlock(`Pallet \`${pallet.name}\`'s constants`);
             defTypeOut += `${stringCamelCase(pallet.name)}: {
         ${typedConstants.map(({ name, type, docs }) => `${commentBlock(docs)}${name}: ${type}`).join(',\n')}

package/chaintypes/generator/ErrorsGen.js

@@ -1,5 +1,6 @@
 import { assert, stringCamelCase, stringPascalCase } from '@dedot/utils';
 import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
+import { getVariantDeprecationComment } from '../../utils.js';
 import { ApiGen } from './ApiGen.js';
 export class ErrorsGen extends ApiGen {
     generate(useSubPaths = false) {
@@ -16,6 +17,14 @@ export class ErrorsGen extends ApiGen {
             defTypeOut += commentBlock(`Pallet \`${pallet.name}\`'s errors`);
             defTypeOut += `${stringCamelCase(pallet.name)}: {
         ${errorDefs
+                .map((def, index) => {
+                const { docs } = def;
+                const deprecationComments = getVariantDeprecationComment(errorTypeId.deprecationInfo, index);
+                if (deprecationComments.length > 0) {
+                    docs.push('\n', ...deprecationComments);
+                }
+                return { ...def, docs };
+            })
                 .map(({ name, docs }) => `${commentBlock(docs)}${stringPascalCase(name)}: GenericPalletError<Rv>`)
                 .join(',\n')}
           

package/chaintypes/generator/EventsGen.js

@@ -1,5 +1,6 @@
 import { assert, stringCamelCase, stringPascalCase } from '@dedot/utils';
 import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
+import { getVariantDeprecationComment } from '../../utils.js';
 import { ApiGen } from './ApiGen.js';
 export class EventsGen extends ApiGen {
     generate(useSubPaths = false) {
@@ -17,7 +18,7 @@ export class EventsGen extends ApiGen {
             defTypeOut += commentBlock(`Pallet \`${pallet.name}\`'s events`);
             defTypeOut += `${stringCamelCase(pallet.name)}: {
         ${eventDefs
-                .map((def) => {
+                .map((def, index) => {
                 const genericParts = [`'${pallet.name}'`, `'${def.name}'`];
                 const eventDataPart = this.#generateMemberDefType(def.fields);
                 if (eventDataPart) {
@@ -26,9 +27,14 @@ export class EventsGen extends ApiGen {
                 else {
                     genericParts.push(flatMembers ? 'undefined' : 'null');
                 }
-                return { ...def, genericParts };
+                const { docs } = def;
+                const deprecationComments = getVariantDeprecationComment(eventTypeId.deprecationInfo, index);
+                if (deprecationComments.length > 0) {
+                    docs.push('\n', ...deprecationComments);
+                }
+                return { ...def, genericParts, docs };
             })
-                .map(({ name, docs, fields, genericParts }) => `${commentBlock(docs)}${stringPascalCase(name)}: GenericPalletEvent<Rv, ${genericParts.join(', ')}>`)
+                .map(({ name, docs, genericParts }) => `${commentBlock(docs)}${stringPascalCase(name)}: GenericPalletEvent<Rv, ${genericParts.join(', ')}>`)
                 .join(',\n')}
           
         ${commentBlock('Generic pallet event')}[prop: string]: GenericPalletEvent<Rv>,

package/chaintypes/generator/QueryGen.js

@@ -1,5 +1,6 @@
 import { normalizeName, stringCamelCase } from '@dedot/utils';
 import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
+import { getDeprecationComment } from '../../utils.js';
 import { ApiGen } from './ApiGen.js';
 export class QueryGen extends ApiGen {
     generate(useSubPaths = false) {
@@ -32,7 +33,7 @@ export class QueryGen extends ApiGen {
         return beautifySourceCode(template({ importTypes, defTypeOut }));
     }
     #generateEntry(entry) {
-        const { name, storageType, docs, modifier } = entry;
+        const { name, storageType, docs, modifier, deprecationInfo } = entry;
         let valueType, keyTypeOut, keyTypeIn;
         if (storageType.type === 'Plain') {
             valueType = this.typesGen.generateType(storageType.value.valueTypeId, 1, true);
@@ -52,6 +53,10 @@ export class QueryGen extends ApiGen {
             docs.push(`@param {${keyTypeIn}} arg`);
         }
         docs.push(`@param {Callback<${valueType}> =} callback`);
+        const deprecationComments = getDeprecationComment(deprecationInfo);
+        if (deprecationComments.length > 0) {
+            docs.push('\n', ...deprecationComments);
+        }
         return {
             name: normalizeName(name),
             valueType,

package/chaintypes/generator/RuntimeApisGen.js

@@ -2,6 +2,7 @@ import { getRuntimeApiNames, getRuntimeApiSpecs } from '@dedot/runtime-specs';
 import { calcRuntimeApiHash, stringSnakeCase, stringCamelCase } from '@dedot/utils';
 import { findKnownCodecType } from '../../shared/index.js';
 import { beautifySourceCode, commentBlock, compileTemplate, isNativeType, TUPLE_TYPE_REGEX, WRAPPER_TYPE_REGEX, } from '../../utils.js';
+import { getDeprecationComment } from '../../utils.js';
 import { ApiGen } from './ApiGen.js';
 export class RuntimeApisGen extends ApiGen {
     typesGen;
@@ -71,13 +72,17 @@ export class RuntimeApisGen extends ApiGen {
         return `${commentBlock(docs, '\n', defaultDocs, typedParams.map(({ plainType, name }) => `@param {${plainType}} ${name}`))}${methodName}: GenericRuntimeApiMethod<Rv, (${paramsOut}) => Promise<${typeOut}>>`;
     }
     #generateMethodDef(runtimeApiName, methodDef) {
-        const { name: methodName, inputs, output, docs } = methodDef;
+        const { name: methodName, inputs, output, docs, deprecationInfo } = methodDef;
         const callName = `${runtimeApiName}_${stringSnakeCase(methodName)}`;
         const defaultDocs = [`@callname: ${callName}`];
+        const deprecationComments = getDeprecationComment(deprecationInfo);
+        if (deprecationComments.length > 0) {
+            deprecationComments.unshift('\n');
+        }
         const typeOut = this.typesGen.generateType(output, 1, true);
         this.#addTypeImport(typeOut, false);
         const typedInputs = inputs
-            .map((input, idx) => ({
+            .map((input) => ({
             ...input,
             type: this.typesGen.generateType(input.typeId, 1),
         }))
@@ -89,7 +94,7 @@ export class RuntimeApisGen extends ApiGen {
         const paramsOut = typedInputs
             .map(({ name, type, isOptional }) => `${stringCamelCase(name)}${isOptional ? '?' : ''}: ${type}`)
             .join(', ');
-        return `${commentBlock(docs, '\n', defaultDocs, typedInputs.map(({ type, name }) => `@param {${type}} ${name}`))}${stringCamelCase(methodName)}: GenericRuntimeApiMethod<Rv, (${paramsOut}) => Promise<${typeOut}>>`;
+        return `${commentBlock(docs, '\n', defaultDocs, typedInputs.map(({ type, name }) => `@param {${type}} ${name}`), deprecationComments)}${stringCamelCase(methodName)}: GenericRuntimeApiMethod<Rv, (${paramsOut}) => Promise<${typeOut}>>`;
     }
     #targetRuntimeApiSpecs() {
         const specs = Object.entries(this.runtimeApis).map(([runtimeApiHash, version]) => {

package/chaintypes/generator/TxGen.js

@@ -1,5 +1,5 @@
 import { stringCamelCase, stringPascalCase } from '@dedot/utils';
-import { beautifySourceCode, commentBlock, compileTemplate, isReservedWord } from '../../utils.js';
+import { beautifySourceCode, commentBlock, compileTemplate, isReservedWord, getVariantDeprecationComment, } from '../../utils.js';
 import { ApiGen } from '../generator/index.js';
 export class TxGen extends ApiGen {
     generate(useSubPaths = false) {
@@ -22,7 +22,7 @@ export class TxGen extends ApiGen {
                 continue;
             const isFlatEnum = typeDef.value.members.every((m) => m.fields.length === 0);
             const typedTxs = typeDef.value.members
-                .map((one) => ({
+                .map((one, index) => ({
                 functionName: stringCamelCase(one.name),
                 params: one.fields.map((f) => ({
                     name: stringCamelCase(f.name),
@@ -31,6 +31,7 @@ export class TxGen extends ApiGen {
                     docs: f.docs,
                 })),
                 docs: one.docs,
+                index,
             }))
                 .map((f) => {
                 return {
@@ -41,7 +42,13 @@ export class TxGen extends ApiGen {
             txDefsOut += commentBlock(`Pallet \`${pallet.name}\`'s transaction calls`);
             txDefsOut += `${stringCamelCase(pallet.name)}: {
           ${typedTxs
-                .map(({ functionName, params, docs, callInput }) => `${commentBlock(docs, '\n', params.map((p) => `@param {${p.type}} ${p.normalizedName} ${p.docs}`))}${functionName}: GenericTxCall<Rv, (${params.map((p) => `${p.normalizedName}: ${p.type}`).join(', ')}) => ChainSubmittableExtrinsic<Rv, ${callInput}>>`)
+                .map(({ functionName, params, docs, callInput }, idx) => {
+                const deprecationComments = getVariantDeprecationComment(pallet.calls?.deprecationInfo, idx);
+                if (deprecationComments.length > 0) {
+                    deprecationComments.unshift('\n');
+                }
+                return `${commentBlock(docs, '\n', params.map((p) => `@param {${p.type}} ${p.normalizedName} ${p.docs}`), deprecationComments)}${functionName}: GenericTxCall<Rv, (${params.map((p) => `${p.normalizedName}: ${p.type}`).join(', ')}) => ChainSubmittableExtrinsic<Rv, ${callInput}>>`;
+            })
                 .join(',\n')}
             
           ${commentBlock('Generic pallet tx call')}[callName: string]: GenericTxCall<Rv, TxCall<Rv>>,

package/chaintypes/generator/ViewFunctionsGen.d.ts

@@ -0,0 +1,4 @@
+import { ApiGen } from './ApiGen.js';
+export declare class ViewFunctionsGen extends ApiGen {
+    generate(useSubPaths?: boolean): Promise<string>;
+}

package/chaintypes/generator/ViewFunctionsGen.js

@@ -0,0 +1,40 @@
+import { stringCamelCase } from '@dedot/utils';
+import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
+import { getDeprecationComment } from '../../utils.js';
+import { ApiGen } from './ApiGen.js';
+export class ViewFunctionsGen extends ApiGen {
+    generate(useSubPaths = false) {
+        const { pallets } = this.metadata;
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericChainViewFunctions', // --
+        'GenericViewFunction', 'RpcVersion');
+        let defTypeOut = '';
+        for (let pallet of pallets) {
+            if (!pallet.viewFunctions || pallet.viewFunctions.length === 0)
+                continue;
+            const viewFns = pallet.viewFunctions.map((vf) => {
+                const { docs, deprecationInfo } = vf;
+                const paramsDoc = vf.inputs.map((input) => `@param {${this.typesGen.generateType(input.typeId, 1)}} ${stringCamelCase(input.name)}`);
+                if (paramsDoc.length > 0) {
+                    docs.push('\n', ...paramsDoc);
+                }
+                const deprecationComments = getDeprecationComment(deprecationInfo);
+                if (deprecationComments.length > 0) {
+                    docs.push('\n', ...deprecationComments);
+                }
+                const params = vf.inputs.map((input) => `${stringCamelCase(input.name)}: ${this.typesGen.generateType(input.typeId, 1)}`);
+                const outputType = this.typesGen.generateType(vf.output, 1, true);
+                return `${commentBlock(docs)}${stringCamelCase(vf.name)}: GenericViewFunction<Rv, (${params.join(', ')}) => Promise<${outputType}>>`;
+            });
+            defTypeOut += commentBlock(`Pallet \`${pallet.name}\`'s view functions`);
+            defTypeOut += `${stringCamelCase(pallet.name)}: {
+        ${viewFns.join(',\n')}
+        
+        ${commentBlock('Generic pallet view function')}[name: string]: GenericViewFunction<Rv>;
+      },`;
+        }
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = compileTemplate('chaintypes/templates/view-functions.hbs');
+        return beautifySourceCode(template({ importTypes, defTypeOut }));
+    }
+}

package/chaintypes/generator/index.d.ts

@@ -8,3 +8,4 @@ export * from './ErrorsGen.js';
 export * from './EventsGen.js';
 export * from './TxGen.js';
 export * from './RuntimeApisGen.js';
+export * from './ViewFunctionsGen.js';

package/chaintypes/generator/index.js

@@ -8,3 +8,4 @@ export * from './ErrorsGen.js';
 export * from './EventsGen.js';
 export * from './TxGen.js';
 export * from './RuntimeApisGen.js';
+export * from './ViewFunctionsGen.js';

package/chaintypes/index.js

@@ -3,7 +3,7 @@ import { WsProvider } from '@dedot/providers';
 import { stringDashCase, stringPascalCase } from '@dedot/utils';
 import * as fs from 'fs';
 import * as path from 'path';
-import { ConstsGen, ErrorsGen, EventsGen, IndexGen, JsonRpcGen, QueryGen, RuntimeApisGen, TxGen, TypesGen, } from './generator/index.js';
+import { ConstsGen, ErrorsGen, EventsGen, IndexGen, JsonRpcGen, QueryGen, RuntimeApisGen, TxGen, ViewFunctionsGen, TypesGen, } from './generator/index.js';
 export async function generateTypesFromEndpoint(chain, endpoint, outDir, extension = 'd.ts', useSubPaths = false) {
     // Immediately throw error if cannot connect to provider for the first time.
     const client = await LegacyClient.new(new WsProvider({ endpoint, retryDelayMs: 0, timeout: 0 }));
@@ -24,6 +24,7 @@ export async function generateTypes(chain, metadata, rpcMethods, runtimeVersion,
     const eventsFileName = path.join(dirPath, `events.${extension}`);
     const runtimeApisFileName = path.join(dirPath, `runtime.${extension}`);
     const txFileName = path.join(dirPath, `tx.${extension}`);
+    const viewFunctionsFileName = path.join(dirPath, `view-functions.${extension}`);
     if (!fs.existsSync(dirPath)) {
         fs.mkdirSync(dirPath, { recursive: true });
     }
@@ -37,6 +38,7 @@ export async function generateTypes(chain, metadata, rpcMethods, runtimeVersion,
     const eventsGen = new EventsGen(typesGen);
     const runtimeApisGen = new RuntimeApisGen(typesGen, runtimeVersion.apis);
     const txGen = new TxGen(typesGen);
+    const viewFunctionGen = new ViewFunctionsGen(typesGen);
     fs.writeFileSync(defTypesFileName, await typesGen.generate(useSubPaths));
     fs.writeFileSync(errorsFileName, await errorsGen.generate(useSubPaths));
     fs.writeFileSync(eventsFileName, await eventsGen.generate(useSubPaths));
@@ -46,5 +48,6 @@ export async function generateTypes(chain, metadata, rpcMethods, runtimeVersion,
     fs.writeFileSync(txFileName, await txGen.generate(useSubPaths));
     fs.writeFileSync(indexFileName, await indexGen.generate(useSubPaths));
     fs.writeFileSync(runtimeApisFileName, await runtimeApisGen.generate(useSubPaths));
+    fs.writeFileSync(viewFunctionsFileName, await viewFunctionGen.generate(useSubPaths));
     return { interfaceName, outputFolder: dirPath };
 }

package/chaintypes/templates/index.hbs

@@ -7,6 +7,7 @@ import { ChainJsonRpcApis } from './json-rpc.js';
 import { ChainErrors } from './errors.js';
 import { ChainEvents } from './events.js';
 import { RuntimeApis } from './runtime.js';
+import { ChainViewFunctions } from './view-functions.js';
 import { ChainTx } from './tx.js';
 
 export * from './types.js';
@@ -18,6 +19,7 @@ export interface Versioned{{{interfaceName}}}<Rv extends RpcVersion> extends Gen
   errors: ChainErrors<Rv>;
   events: ChainEvents<Rv>;
   call: RuntimeApis<Rv>;
+  view: ChainViewFunctions<Rv>;
   tx: ChainTx<Rv>;
 }
 

package/chaintypes/templates/view-functions.hbs

@@ -0,0 +1,7 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+export interface ChainViewFunctions<Rv extends RpcVersion> extends GenericChainViewFunctions<Rv> {
+  {{{ defTypeOut }}}
+}

package/cjs/chaintypes/generator/ConstsGen.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConstsGen = void 0;
 const utils_1 = require("@dedot/utils");
 const utils_js_1 = require("../../utils.js");
+const utils_js_2 = require("../../utils.js");
 const ApiGen_js_1 = require("./ApiGen.js");
 class ConstsGen extends ApiGen_js_1.ApiGen {
     generate(useSubPaths = false) {
@@ -11,11 +12,18 @@ class ConstsGen extends ApiGen_js_1.ApiGen {
         this.typesGen.typeImports.addKnownType('GenericChainConsts', 'RpcVersion');
         let defTypeOut = '';
         for (let pallet of pallets) {
-            const typedConstants = pallet.constants.map((one) => ({
-                name: (0, utils_1.normalizeName)(one.name),
-                type: this.typesGen.generateType(one.typeId, 1, true),
-                docs: one.docs,
-            }));
+            const typedConstants = pallet.constants.map((one) => {
+                const { deprecationInfo, docs } = one;
+                const deprecationComments = (0, utils_js_2.getDeprecationComment)(deprecationInfo);
+                if (deprecationComments.length > 0) {
+                    docs.push('\n', ...deprecationComments);
+                }
+                return {
+                    name: (0, utils_1.normalizeName)(one.name),
+                    type: this.typesGen.generateType(one.typeId, 1, true),
+                    docs,
+                };
+            });
             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')}

package/cjs/chaintypes/generator/ErrorsGen.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErrorsGen = void 0;
 const utils_1 = require("@dedot/utils");
 const utils_js_1 = require("../../utils.js");
+const utils_js_2 = require("../../utils.js");
 const ApiGen_js_1 = require("./ApiGen.js");
 class ErrorsGen extends ApiGen_js_1.ApiGen {
     generate(useSubPaths = false) {
@@ -19,6 +20,14 @@ class ErrorsGen extends ApiGen_js_1.ApiGen {
             defTypeOut += (0, utils_js_1.commentBlock)(`Pallet \`${pallet.name}\`'s errors`);
             defTypeOut += `${(0, utils_1.stringCamelCase)(pallet.name)}: {
         ${errorDefs
+                .map((def, index) => {
+                const { docs } = def;
+                const deprecationComments = (0, utils_js_2.getVariantDeprecationComment)(errorTypeId.deprecationInfo, index);
+                if (deprecationComments.length > 0) {
+                    docs.push('\n', ...deprecationComments);
+                }
+                return { ...def, docs };
+            })
                 .map(({ name, docs }) => `${(0, utils_js_1.commentBlock)(docs)}${(0, utils_1.stringPascalCase)(name)}: GenericPalletError<Rv>`)
                 .join(',\n')}
           

package/cjs/chaintypes/generator/EventsGen.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventsGen = void 0;
 const utils_1 = require("@dedot/utils");
 const utils_js_1 = require("../../utils.js");
+const utils_js_2 = require("../../utils.js");
 const ApiGen_js_1 = require("./ApiGen.js");
 class EventsGen extends ApiGen_js_1.ApiGen {
     generate(useSubPaths = false) {
@@ -20,7 +21,7 @@ class EventsGen extends ApiGen_js_1.ApiGen {
             defTypeOut += (0, utils_js_1.commentBlock)(`Pallet \`${pallet.name}\`'s events`);
             defTypeOut += `${(0, utils_1.stringCamelCase)(pallet.name)}: {
         ${eventDefs
-                .map((def) => {
+                .map((def, index) => {
                 const genericParts = [`'${pallet.name}'`, `'${def.name}'`];
                 const eventDataPart = this.#generateMemberDefType(def.fields);
                 if (eventDataPart) {
@@ -29,9 +30,14 @@ class EventsGen extends ApiGen_js_1.ApiGen {
                 else {
                     genericParts.push(flatMembers ? 'undefined' : 'null');
                 }
-                return { ...def, genericParts };
+                const { docs } = def;
+                const deprecationComments = (0, utils_js_2.getVariantDeprecationComment)(eventTypeId.deprecationInfo, index);
+                if (deprecationComments.length > 0) {
+                    docs.push('\n', ...deprecationComments);
+                }
+                return { ...def, genericParts, docs };
             })
-                .map(({ name, docs, fields, genericParts }) => `${(0, utils_js_1.commentBlock)(docs)}${(0, utils_1.stringPascalCase)(name)}: GenericPalletEvent<Rv, ${genericParts.join(', ')}>`)
+                .map(({ name, docs, genericParts }) => `${(0, utils_js_1.commentBlock)(docs)}${(0, utils_1.stringPascalCase)(name)}: GenericPalletEvent<Rv, ${genericParts.join(', ')}>`)
                 .join(',\n')}
           
         ${(0, utils_js_1.commentBlock)('Generic pallet event')}[prop: string]: GenericPalletEvent<Rv>,

package/cjs/chaintypes/generator/QueryGen.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryGen = void 0;
 const utils_1 = require("@dedot/utils");
 const utils_js_1 = require("../../utils.js");
+const utils_js_2 = require("../../utils.js");
 const ApiGen_js_1 = require("./ApiGen.js");
 class QueryGen extends ApiGen_js_1.ApiGen {
     generate(useSubPaths = false) {
@@ -35,7 +36,7 @@ class QueryGen extends ApiGen_js_1.ApiGen {
         return (0, utils_js_1.beautifySourceCode)(template({ importTypes, defTypeOut }));
     }
     #generateEntry(entry) {
-        const { name, storageType, docs, modifier } = entry;
+        const { name, storageType, docs, modifier, deprecationInfo } = entry;
         let valueType, keyTypeOut, keyTypeIn;
         if (storageType.type === 'Plain') {
             valueType = this.typesGen.generateType(storageType.value.valueTypeId, 1, true);
@@ -55,6 +56,10 @@ class QueryGen extends ApiGen_js_1.ApiGen {
             docs.push(`@param {${keyTypeIn}} arg`);
         }
         docs.push(`@param {Callback<${valueType}> =} callback`);
+        const deprecationComments = (0, utils_js_2.getDeprecationComment)(deprecationInfo);
+        if (deprecationComments.length > 0) {
+            docs.push('\n', ...deprecationComments);
+        }
         return {
             name: (0, utils_1.normalizeName)(name),
             valueType,

package/cjs/chaintypes/generator/RuntimeApisGen.js

@@ -5,6 +5,7 @@ const runtime_specs_1 = require("@dedot/runtime-specs");
 const utils_1 = require("@dedot/utils");
 const index_js_1 = require("../../shared/index.js");
 const utils_js_1 = require("../../utils.js");
+const utils_js_2 = require("../../utils.js");
 const ApiGen_js_1 = require("./ApiGen.js");
 class RuntimeApisGen extends ApiGen_js_1.ApiGen {
     typesGen;
@@ -74,13 +75,17 @@ class RuntimeApisGen extends ApiGen_js_1.ApiGen {
         return `${(0, utils_js_1.commentBlock)(docs, '\n', defaultDocs, typedParams.map(({ plainType, name }) => `@param {${plainType}} ${name}`))}${methodName}: GenericRuntimeApiMethod<Rv, (${paramsOut}) => Promise<${typeOut}>>`;
     }
     #generateMethodDef(runtimeApiName, methodDef) {
-        const { name: methodName, inputs, output, docs } = methodDef;
+        const { name: methodName, inputs, output, docs, deprecationInfo } = methodDef;
         const callName = `${runtimeApiName}_${(0, utils_1.stringSnakeCase)(methodName)}`;
         const defaultDocs = [`@callname: ${callName}`];
+        const deprecationComments = (0, utils_js_2.getDeprecationComment)(deprecationInfo);
+        if (deprecationComments.length > 0) {
+            deprecationComments.unshift('\n');
+        }
         const typeOut = this.typesGen.generateType(output, 1, true);
         this.#addTypeImport(typeOut, false);
         const typedInputs = inputs
-            .map((input, idx) => ({
+            .map((input) => ({
             ...input,
             type: this.typesGen.generateType(input.typeId, 1),
         }))
@@ -92,7 +97,7 @@ class RuntimeApisGen extends ApiGen_js_1.ApiGen {
         const paramsOut = typedInputs
             .map(({ name, type, isOptional }) => `${(0, utils_1.stringCamelCase)(name)}${isOptional ? '?' : ''}: ${type}`)
             .join(', ');
-        return `${(0, utils_js_1.commentBlock)(docs, '\n', defaultDocs, typedInputs.map(({ type, name }) => `@param {${type}} ${name}`))}${(0, utils_1.stringCamelCase)(methodName)}: GenericRuntimeApiMethod<Rv, (${paramsOut}) => Promise<${typeOut}>>`;
+        return `${(0, utils_js_1.commentBlock)(docs, '\n', defaultDocs, typedInputs.map(({ type, name }) => `@param {${type}} ${name}`), deprecationComments)}${(0, utils_1.stringCamelCase)(methodName)}: GenericRuntimeApiMethod<Rv, (${paramsOut}) => Promise<${typeOut}>>`;
     }
     #targetRuntimeApiSpecs() {
         const specs = Object.entries(this.runtimeApis).map(([runtimeApiHash, version]) => {

package/cjs/chaintypes/generator/TxGen.js

@@ -25,7 +25,7 @@ class TxGen extends index_js_1.ApiGen {
                 continue;
             const isFlatEnum = typeDef.value.members.every((m) => m.fields.length === 0);
             const typedTxs = typeDef.value.members
-                .map((one) => ({
+                .map((one, index) => ({
                 functionName: (0, utils_1.stringCamelCase)(one.name),
                 params: one.fields.map((f) => ({
                     name: (0, utils_1.stringCamelCase)(f.name),
@@ -34,6 +34,7 @@ class TxGen extends index_js_1.ApiGen {
                     docs: f.docs,
                 })),
                 docs: one.docs,
+                index,
             }))
                 .map((f) => {
                 return {
@@ -44,7 +45,13 @@ class TxGen extends index_js_1.ApiGen {
             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_js_1.commentBlock)(docs, '\n', params.map((p) => `@param {${p.type}} ${p.normalizedName} ${p.docs}`))}${functionName}: GenericTxCall<Rv, (${params.map((p) => `${p.normalizedName}: ${p.type}`).join(', ')}) => ChainSubmittableExtrinsic<Rv, ${callInput}>>`)
+                .map(({ functionName, params, docs, callInput }, idx) => {
+                const deprecationComments = (0, utils_js_1.getVariantDeprecationComment)(pallet.calls?.deprecationInfo, idx);
+                if (deprecationComments.length > 0) {
+                    deprecationComments.unshift('\n');
+                }
+                return `${(0, utils_js_1.commentBlock)(docs, '\n', params.map((p) => `@param {${p.type}} ${p.normalizedName} ${p.docs}`), deprecationComments)}${functionName}: GenericTxCall<Rv, (${params.map((p) => `${p.normalizedName}: ${p.type}`).join(', ')}) => ChainSubmittableExtrinsic<Rv, ${callInput}>>`;
+            })
                 .join(',\n')}
             
           ${(0, utils_js_1.commentBlock)('Generic pallet tx call')}[callName: string]: GenericTxCall<Rv, TxCall<Rv>>,

package/cjs/chaintypes/generator/ViewFunctionsGen.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViewFunctionsGen = void 0;
+const utils_1 = require("@dedot/utils");
+const utils_js_1 = require("../../utils.js");
+const utils_js_2 = require("../../utils.js");
+const ApiGen_js_1 = require("./ApiGen.js");
+class ViewFunctionsGen extends ApiGen_js_1.ApiGen {
+    generate(useSubPaths = false) {
+        const { pallets } = this.metadata;
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericChainViewFunctions', // --
+        'GenericViewFunction', 'RpcVersion');
+        let defTypeOut = '';
+        for (let pallet of pallets) {
+            if (!pallet.viewFunctions || pallet.viewFunctions.length === 0)
+                continue;
+            const viewFns = pallet.viewFunctions.map((vf) => {
+                const { docs, deprecationInfo } = vf;
+                const paramsDoc = vf.inputs.map((input) => `@param {${this.typesGen.generateType(input.typeId, 1)}} ${(0, utils_1.stringCamelCase)(input.name)}`);
+                if (paramsDoc.length > 0) {
+                    docs.push('\n', ...paramsDoc);
+                }
+                const deprecationComments = (0, utils_js_2.getDeprecationComment)(deprecationInfo);
+                if (deprecationComments.length > 0) {
+                    docs.push('\n', ...deprecationComments);
+                }
+                const params = vf.inputs.map((input) => `${(0, utils_1.stringCamelCase)(input.name)}: ${this.typesGen.generateType(input.typeId, 1)}`);
+                const outputType = this.typesGen.generateType(vf.output, 1, true);
+                return `${(0, utils_js_1.commentBlock)(docs)}${(0, utils_1.stringCamelCase)(vf.name)}: GenericViewFunction<Rv, (${params.join(', ')}) => Promise<${outputType}>>`;
+            });
+            defTypeOut += (0, utils_js_1.commentBlock)(`Pallet \`${pallet.name}\`'s view functions`);
+            defTypeOut += `${(0, utils_1.stringCamelCase)(pallet.name)}: {
+        ${viewFns.join(',\n')}
+        
+        ${(0, utils_js_1.commentBlock)('Generic pallet view function')}[name: string]: GenericViewFunction<Rv>;
+      },`;
+        }
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = (0, utils_js_1.compileTemplate)('chaintypes/templates/view-functions.hbs');
+        return (0, utils_js_1.beautifySourceCode)(template({ importTypes, defTypeOut }));
+    }
+}
+exports.ViewFunctionsGen = ViewFunctionsGen;

package/cjs/chaintypes/generator/index.js

@@ -24,3 +24,4 @@ __exportStar(require("./ErrorsGen.js"), exports);
 __exportStar(require("./EventsGen.js"), exports);
 __exportStar(require("./TxGen.js"), exports);
 __exportStar(require("./RuntimeApisGen.js"), exports);
+__exportStar(require("./ViewFunctionsGen.js"), exports);

package/cjs/chaintypes/index.js

@@ -51,6 +51,7 @@ async function generateTypes(chain, metadata, rpcMethods, runtimeVersion, outDir
     const eventsFileName = path.join(dirPath, `events.${extension}`);
     const runtimeApisFileName = path.join(dirPath, `runtime.${extension}`);
     const txFileName = path.join(dirPath, `tx.${extension}`);
+    const viewFunctionsFileName = path.join(dirPath, `view-functions.${extension}`);
     if (!fs.existsSync(dirPath)) {
         fs.mkdirSync(dirPath, { recursive: true });
     }
@@ -64,6 +65,7 @@ async function generateTypes(chain, metadata, rpcMethods, runtimeVersion, outDir
     const eventsGen = new index_js_1.EventsGen(typesGen);
     const runtimeApisGen = new index_js_1.RuntimeApisGen(typesGen, runtimeVersion.apis);
     const txGen = new index_js_1.TxGen(typesGen);
+    const viewFunctionGen = new index_js_1.ViewFunctionsGen(typesGen);
     fs.writeFileSync(defTypesFileName, await typesGen.generate(useSubPaths));
     fs.writeFileSync(errorsFileName, await errorsGen.generate(useSubPaths));
     fs.writeFileSync(eventsFileName, await eventsGen.generate(useSubPaths));
@@ -73,6 +75,7 @@ async function generateTypes(chain, metadata, rpcMethods, runtimeVersion, outDir
     fs.writeFileSync(txFileName, await txGen.generate(useSubPaths));
     fs.writeFileSync(indexFileName, await indexGen.generate(useSubPaths));
     fs.writeFileSync(runtimeApisFileName, await runtimeApisGen.generate(useSubPaths));
+    fs.writeFileSync(viewFunctionsFileName, await viewFunctionGen.generate(useSubPaths));
     return { interfaceName, outputFolder: dirPath };
 }
 exports.generateTypes = generateTypes;

package/cjs/chaintypes/templates/index.hbs

@@ -7,6 +7,7 @@ import { ChainJsonRpcApis } from './json-rpc.js';
 import { ChainErrors } from './errors.js';
 import { ChainEvents } from './events.js';
 import { RuntimeApis } from './runtime.js';
+import { ChainViewFunctions } from './view-functions.js';
 import { ChainTx } from './tx.js';
 
 export * from './types.js';
@@ -18,6 +19,7 @@ export interface Versioned{{{interfaceName}}}<Rv extends RpcVersion> extends Gen
   errors: ChainErrors<Rv>;
   events: ChainEvents<Rv>;
   call: RuntimeApis<Rv>;
+  view: ChainViewFunctions<Rv>;
   tx: ChainTx<Rv>;
 }
 

package/cjs/chaintypes/templates/view-functions.hbs

@@ -0,0 +1,7 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+export interface ChainViewFunctions<Rv extends RpcVersion> extends GenericChainViewFunctions<Rv> {
+  {{{ defTypeOut }}}
+}

package/cjs/utils.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNativeType = exports.isReservedWord = exports.compileTemplate = exports.beautifySourceCode = exports.commentBlock = exports.TUPLE_TYPE_REGEX = exports.WRAPPER_TYPE_REGEX = void 0;
+exports.getVariantDeprecationComment = exports.getDeprecationComment = exports.isNativeType = exports.isReservedWord = exports.compileTemplate = exports.beautifySourceCode = exports.commentBlock = exports.TUPLE_TYPE_REGEX = exports.WRAPPER_TYPE_REGEX = void 0;
 const fs = __importStar(require("fs"));
 const handlebars_1 = __importDefault(require("handlebars"));
 const path = __importStar(require("path"));
@@ -95,3 +95,49 @@ const isNativeType = (type) => {
     });
 };
 exports.isNativeType = isNativeType;
+/**
+ * Generate deprecation comment from ItemDeprecationInfoDefV16
+ *
+ * @param deprecationInfo - The deprecation information for the item
+ */
+const getDeprecationComment = (deprecationInfo) => {
+    if (!deprecationInfo) {
+        return [];
+    }
+    switch (deprecationInfo.type) {
+        case 'DeprecatedWithoutNote':
+            return ['@deprecated'];
+        case 'Deprecated': {
+            const { note, since } = deprecationInfo.value;
+            return [`@deprecated ${note}${since ? ` (since ${since})` : ''}`];
+        }
+        case 'NotDeprecated':
+        default:
+            return [];
+    }
+};
+exports.getDeprecationComment = getDeprecationComment;
+/**
+ * Generate deprecation comment for enum variant from EnumDeprecationInfoDefV16
+ *
+ * @param deprecationInfo - The deprecation information for the enum
+ * @param variantIndex
+ */
+const getVariantDeprecationComment = (deprecationInfo, variantIndex) => {
+    if (!deprecationInfo || !deprecationInfo[0])
+        return [];
+    const variantDeprecation = deprecationInfo[0].get(variantIndex);
+    if (!variantDeprecation)
+        return [];
+    switch (variantDeprecation.type) {
+        case 'DeprecatedWithoutNote':
+            return ['@deprecated'];
+        case 'Deprecated': {
+            const { note, since } = variantDeprecation.value;
+            return [`@deprecated ${note}${since ? ` (since ${since})` : ''}`];
+        }
+        default:
+            return [];
+    }
+};
+exports.getVariantDeprecationComment = getVariantDeprecationComment;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/codegen",
-  "version": "0.14.1",
+  "version": "0.15.1",
   "description": "Generate types",
   "author": "Thang X. Vu <thang@dedot.dev>",
   "homepage": "https://dedot.dev",
@@ -18,14 +18,14 @@
     "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/api": "0.14.1",
-    "@dedot/codecs": "0.14.1",
-    "@dedot/contracts": "0.14.1",
-    "@dedot/providers": "0.14.1",
-    "@dedot/runtime-specs": "0.14.1",
-    "@dedot/shape": "0.14.1",
-    "@dedot/types": "0.14.1",
-    "@dedot/utils": "0.14.1",
+    "@dedot/api": "0.15.1",
+    "@dedot/codecs": "0.15.1",
+    "@dedot/contracts": "0.15.1",
+    "@dedot/providers": "0.15.1",
+    "@dedot/runtime-specs": "0.15.1",
+    "@dedot/shape": "0.15.1",
+    "@dedot/types": "0.15.1",
+    "@dedot/utils": "0.15.1",
     "handlebars": "^4.7.8",
     "prettier": "^3.5.3"
   },
@@ -37,7 +37,7 @@
     "node": ">=18"
   },
   "license": "Apache-2.0",
-  "gitHead": "d5adec49781a6e0b45910055dcaf9bf472a39a6b",
+  "gitHead": "fdac8072dc7ea6698f19f11604904b665ec7ba89",
   "module": "./index.js",
   "types": "./index.d.ts",
   "exports": {

package/utils.d.ts

@@ -1,3 +1,4 @@
+import { ItemDeprecationInfoDefV16, EnumDeprecationInfoDefV16 } from '@dedot/codecs';
 export declare const WRAPPER_TYPE_REGEX: RegExp;
 export declare const TUPLE_TYPE_REGEX: RegExp;
 export declare const commentBlock: (...docs: (string | string[])[]) => string;
@@ -13,3 +14,16 @@ export declare const isReservedWord: (word: string) => boolean;
  * @param type
  */
 export declare const isNativeType: (type: string) => boolean;
+/**
+ * Generate deprecation comment from ItemDeprecationInfoDefV16
+ *
+ * @param deprecationInfo - The deprecation information for the item
+ */
+export declare const getDeprecationComment: (deprecationInfo: ItemDeprecationInfoDefV16 | undefined) => string[];
+/**
+ * Generate deprecation comment for enum variant from EnumDeprecationInfoDefV16
+ *
+ * @param deprecationInfo - The deprecation information for the enum
+ * @param variantIndex
+ */
+export declare const getVariantDeprecationComment: (deprecationInfo: EnumDeprecationInfoDefV16 | undefined, variantIndex: number) => string[];

package/utils.js

@@ -61,3 +61,47 @@ export const isNativeType = (type) => {
         }
     });
 };
+/**
+ * Generate deprecation comment from ItemDeprecationInfoDefV16
+ *
+ * @param deprecationInfo - The deprecation information for the item
+ */
+export const getDeprecationComment = (deprecationInfo) => {
+    if (!deprecationInfo) {
+        return [];
+    }
+    switch (deprecationInfo.type) {
+        case 'DeprecatedWithoutNote':
+            return ['@deprecated'];
+        case 'Deprecated': {
+            const { note, since } = deprecationInfo.value;
+            return [`@deprecated ${note}${since ? ` (since ${since})` : ''}`];
+        }
+        case 'NotDeprecated':
+        default:
+            return [];
+    }
+};
+/**
+ * Generate deprecation comment for enum variant from EnumDeprecationInfoDefV16
+ *
+ * @param deprecationInfo - The deprecation information for the enum
+ * @param variantIndex
+ */
+export const getVariantDeprecationComment = (deprecationInfo, variantIndex) => {
+    if (!deprecationInfo || !deprecationInfo[0])
+        return [];
+    const variantDeprecation = deprecationInfo[0].get(variantIndex);
+    if (!variantDeprecation)
+        return [];
+    switch (variantDeprecation.type) {
+        case 'DeprecatedWithoutNote':
+            return ['@deprecated'];
+        case 'Deprecated': {
+            const { note, since } = variantDeprecation.value;
+            return [`@deprecated ${note}${since ? ` (since ${since})` : ''}`];
+        }
+        default:
+            return [];
+    }
+};