@dedot/codegen 0.12.1-next.f19f185a.2 → 0.13.0

package/chaintypes/generator/ApiGen.d.ts

@@ -82,33 +82,124 @@ export declare abstract class ApiGen {
                     };
                     default: `0x${string}`;
                     docs: string[];
+                    deprecationInfo: {
+                        type: "NotDeprecated";
+                    } | {
+                        type: "DeprecatedWithoutNote";
+                    } | {
+                        type: "Deprecated";
+                        value: {
+                            note: string;
+                            since: string | undefined;
+                        };
+                    };
                 }[];
             } | undefined;
-            calls: number | undefined;
-            event: number | undefined;
+            calls: {
+                typeId: number;
+                deprecationInfo: readonly [ReadonlyMap<number, {
+                    type: "DeprecatedWithoutNote";
+                } | {
+                    type: "Deprecated";
+                    value: {
+                        note: string;
+                        since: string | undefined;
+                    };
+                }>];
+            } | undefined;
+            event: {
+                typeId: number;
+                deprecationInfo: readonly [ReadonlyMap<number, {
+                    type: "DeprecatedWithoutNote";
+                } | {
+                    type: "Deprecated";
+                    value: {
+                        note: string;
+                        since: string | undefined;
+                    };
+                }>];
+            } | undefined;
             constants: {
                 name: string;
                 typeId: number;
                 value: `0x${string}`;
                 docs: string[];
+                deprecationInfo: {
+                    type: "NotDeprecated";
+                } | {
+                    type: "DeprecatedWithoutNote";
+                } | {
+                    type: "Deprecated";
+                    value: {
+                        note: string;
+                        since: string | undefined;
+                    };
+                };
+            }[];
+            error: {
+                typeId: number;
+                deprecationInfo: readonly [ReadonlyMap<number, {
+                    type: "DeprecatedWithoutNote";
+                } | {
+                    type: "Deprecated";
+                    value: {
+                        note: string;
+                        since: string | undefined;
+                    };
+                }>];
+            } | undefined;
+            associatedTypes: {
+                name: string;
+                typeId: number;
+                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];
+                name: string;
+                inputs: {
+                    name: string;
+                    typeId: number;
+                }[];
+                output: number;
+                docs: string[];
+                deprecationInfo: {
+                    type: "NotDeprecated";
+                } | {
+                    type: "DeprecatedWithoutNote";
+                } | {
+                    type: "Deprecated";
+                    value: {
+                        note: string;
+                        since: string | undefined;
+                    };
+                };
             }[];
-            error: number | undefined;
             index: number;
             docs: string[];
+            deprecationInfo: {
+                type: "NotDeprecated";
+            } | {
+                type: "DeprecatedWithoutNote";
+            } | {
+                type: "Deprecated";
+                value: {
+                    note: string;
+                    since: string | undefined;
+                };
+            };
         }[];
         extrinsic: {
-            version: number;
+            versions: number[];
             addressTypeId: number;
-            callTypeId: number;
             signatureTypeId: number;
-            extraTypeId: number;
+            callTypeId: number;
+            signedExtensionsByVersion: ReadonlyMap<number, number[]>;
             signedExtensions: {
                 ident: string;
                 typeId: number;
                 additionalSigned: number;
             }[];
         };
-        runtimeType: number;
         apis: {
             name: string;
             methods: {
@@ -119,8 +210,31 @@ export declare abstract class ApiGen {
                 }[];
                 output: number;
                 docs: string[];
+                deprecationInfo: {
+                    type: "NotDeprecated";
+                } | {
+                    type: "DeprecatedWithoutNote";
+                } | {
+                    type: "Deprecated";
+                    value: {
+                        note: string;
+                        since: string | undefined;
+                    };
+                };
             }[];
             docs: string[];
+            version: number;
+            deprecationInfo: {
+                type: "NotDeprecated";
+            } | {
+                type: "DeprecatedWithoutNote";
+            } | {
+                type: "Deprecated";
+                value: {
+                    note: string;
+                    since: string | undefined;
+                };
+            };
         }[];
         outerEnums: {
             callEnumTypeId: number;

package/chaintypes/generator/ErrorsGen.js

@@ -12,7 +12,7 @@ export class ErrorsGen extends ApiGen {
             if (!errorTypeId) {
                 continue;
             }
-            const errorDefs = this.#getErrorDefs(errorTypeId);
+            const errorDefs = this.#getErrorDefs(errorTypeId.typeId);
             defTypeOut += commentBlock(`Pallet \`${pallet.name}\`'s errors`);
             defTypeOut += `${stringCamelCase(pallet.name)}: {
         ${errorDefs

package/chaintypes/generator/EventsGen.js

@@ -12,7 +12,7 @@ export class EventsGen extends ApiGen {
             if (!eventTypeId) {
                 continue;
             }
-            const eventDefs = this.#getEventDefs(eventTypeId);
+            const eventDefs = this.#getEventDefs(eventTypeId.typeId);
             const flatMembers = eventDefs.every((d) => d.fields.length === 0);
             defTypeOut += commentBlock(`Pallet \`${pallet.name}\`'s events`);
             defTypeOut += `${stringCamelCase(pallet.name)}: {

package/chaintypes/generator/TxGen.js

@@ -17,7 +17,7 @@ export class TxGen extends ApiGen {
         for (let pallet of pallets) {
             if (pallet.calls === undefined)
                 continue;
-            const { typeDef } = types[pallet.calls];
+            const { typeDef } = types[pallet.calls.typeId];
             if (typeDef.type !== 'Enum')
                 continue;
             const isFlatEnum = typeDef.value.members.every((m) => m.fields.length === 0);

package/cjs/chaintypes/generator/ErrorsGen.js

@@ -15,7 +15,7 @@ class ErrorsGen extends ApiGen_js_1.ApiGen {
             if (!errorTypeId) {
                 continue;
             }
-            const errorDefs = this.#getErrorDefs(errorTypeId);
+            const errorDefs = this.#getErrorDefs(errorTypeId.typeId);
             defTypeOut += (0, utils_js_1.commentBlock)(`Pallet \`${pallet.name}\`'s errors`);
             defTypeOut += `${(0, utils_1.stringCamelCase)(pallet.name)}: {
         ${errorDefs

package/cjs/chaintypes/generator/EventsGen.js

@@ -15,7 +15,7 @@ class EventsGen extends ApiGen_js_1.ApiGen {
             if (!eventTypeId) {
                 continue;
             }
-            const eventDefs = this.#getEventDefs(eventTypeId);
+            const eventDefs = this.#getEventDefs(eventTypeId.typeId);
             const flatMembers = eventDefs.every((d) => d.fields.length === 0);
             defTypeOut += (0, utils_js_1.commentBlock)(`Pallet \`${pallet.name}\`'s events`);
             defTypeOut += `${(0, utils_1.stringCamelCase)(pallet.name)}: {

package/cjs/chaintypes/generator/TxGen.js

@@ -20,7 +20,7 @@ class TxGen extends index_js_1.ApiGen {
         for (let pallet of pallets) {
             if (pallet.calls === undefined)
                 continue;
-            const { typeDef } = types[pallet.calls];
+            const { typeDef } = types[pallet.calls.typeId];
             if (typeDef.type !== 'Enum')
                 continue;
             const isFlatEnum = typeDef.value.members.every((m) => m.fields.length === 0);

package/cjs/typink/generator/IndexGen.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IndexGen = void 0;
+const contracts_1 = require("@dedot/contracts");
 const index_js_1 = require("../../shared/index.js");
 const utils_js_1 = require("../../utils.js");
 class IndexGen {
@@ -18,9 +19,10 @@ class IndexGen {
         const langErrorName = this.typesGen.cleanPath(this.contractMetadata.types[langErrorId].type.path);
         const typeImports = new index_js_1.TypeImports();
         typeImports.addKnownType('VersionedGenericSubstrateApi', 'RpcVersion', 'RpcV2');
-        typeImports.addContractType('GenericContractApi');
+        typeImports.addContractType('GenericContractApi', 'WithLazyStorage');
         typeImports.addChainType('SubstrateApi');
         typeImports.addPortableType(langErrorName);
+        const [rootStorageName, lazyStorageName] = this.#extractRootStorageNames(typeImports);
         const { contract: { name = '', version = '', authors = [] }, source: { language = '' }, } = this.contractMetadata;
         const interfaceDocs = (0, utils_js_1.commentBlock)([
             `@name: ${interfaceName}`, // prettier-end-here
@@ -31,7 +33,28 @@ class IndexGen {
         ]);
         const importTypes = typeImports.toImports({ useSubPaths });
         const template = (0, utils_js_1.compileTemplate)('typink/templates/index.hbs');
-        return (0, utils_js_1.beautifySourceCode)(template({ interfaceName, interfaceDocs, langErrorName, importTypes }));
+        return (0, utils_js_1.beautifySourceCode)(template({
+            interfaceName,
+            interfaceDocs,
+            langErrorName,
+            importTypes,
+            rootStorageName,
+            lazyStorageName,
+        }));
+    }
+    #extractRootStorageNames(typeImports) {
+        try {
+            (0, contracts_1.ensureStorageApiSupports)(this.contractMetadata.version);
+            const { ty: rootStorageId } = this.contractMetadata.storage.root;
+            const rootStorageName = this.typesGen.cleanPath(this.contractMetadata.types[rootStorageId].type.path);
+            typeImports.addPortableType(rootStorageName);
+            return [rootStorageName, `WithLazyStorage<${rootStorageName}>`];
+        }
+        catch {
+            const names = ['GenericRootStorage', 'GenericLazyStorage'];
+            typeImports.addContractType(...names);
+            return names;
+        }
     }
 }
 exports.IndexGen = IndexGen;

package/cjs/typink/generator/TypesGen.js

@@ -26,6 +26,33 @@ class TypesGen extends index_js_1.BaseTypesGen {
         const template = (0, utils_js_1.compileTemplate)('typink/templates/types.hbs');
         return (0, utils_js_1.beautifySourceCode)(template({ importTypes, defTypeOut }));
     }
+    generateType(typeId, nestedLevel = 0, typeOut = false) {
+        const generatedType = super.generateType(typeId, nestedLevel, typeOut);
+        // Lazy types should be inside a wrapper structure/object
+        // So we only check for lazy type when nestedLevel > 0
+        if (nestedLevel > 0) {
+            const types = this.contractMetadata.types;
+            const typeDef = types.find(({ id }) => id == typeId);
+            const lazyType = (0, contracts_1.isLazyType)(typeDef.type.path);
+            if (!lazyType)
+                return generatedType;
+            const [p1, p2] = typeDef.type.params;
+            if (lazyType === contracts_1.KnownLazyType.LAZY) {
+                const ValueType = super.generateType(p1.type, 1, true);
+                return `{ get(): Promise<${ValueType} | undefined> }`;
+            }
+            else if (lazyType === contracts_1.KnownLazyType.MAPPING) {
+                const KeyType = super.generateType(p1.type, 1);
+                const ValueType = super.generateType(p2.type, 1, true);
+                return `{ get(arg: ${KeyType}): Promise<${ValueType} | undefined> }`;
+            }
+            else if (lazyType === contracts_1.KnownLazyType.STORAGE_VEC) {
+                const ValueType = super.generateType(p1.type, 1, true);
+                return `{ len(): Promise<number>; get(index: number): Promise<${ValueType} | undefined> }`;
+            }
+        }
+        return generatedType;
+    }
     shouldGenerateTypeIn(id) {
         const { messages, constructors } = this.contractMetadata.spec;
         return ((this.#idInParameters(id, messages) || this.#idInParameters(id, constructors)) && this.#includeKnownTypes(id));

package/cjs/typink/index.js

@@ -10,7 +10,8 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const index_js_1 = require("./generator/index.js");
 async function generateContractTypes(metadata, contract, outDir = '.', extension = 'd.ts', useSubPaths = false) {
-    let contractMetadata = typeof metadata === 'string' ? (0, contracts_1.parseRawMetadata)(metadata) : metadata;
+    let contractMetadata = typeof metadata === 'string' ? JSON.parse(metadata) : metadata;
+    (0, contracts_1.ensureSupportedContractMetadataVersion)(contractMetadata);
     const contractName = contract || contractMetadata.contract.name;
     const dirPath = path_1.default.resolve(outDir, (0, utils_1.stringDashCase)(contractName));
     const typesFileName = path_1.default.join(dirPath, `types.${extension}`);

package/cjs/typink/templates/index.hbs

@@ -15,8 +15,14 @@ export * from './types.js';
     constructorQuery: ConstructorQuery<ChainApi[Rv]>;
     constructorTx: ConstructorTx<ChainApi[Rv]>;
     events: ContractEvents<ChainApi[Rv]>;
+    storage: {
+      root(): Promise<{{{rootStorageName}}}>;
+      lazy(): {{{lazyStorageName}}};
+    };
 
     types: {
+      RootStorage: {{{rootStorageName}}};
+      LazyStorage: {{{lazyStorageName}}};
       LangError: {{{langErrorName}}};
       ChainApi: ChainApi[Rv];
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/codegen",
-  "version": "0.12.1-next.f19f185a.2+f19f185a",
+  "version": "0.13.0",
   "description": "Generate types",
   "author": "Thang X. Vu <thang@dedot.dev>",
   "homepage": "https://dedot.dev",
@@ -18,16 +18,16 @@
     "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.12.1-next.f19f185a.2+f19f185a",
-    "@dedot/codecs": "0.12.1-next.f19f185a.2+f19f185a",
-    "@dedot/contracts": "0.12.1-next.f19f185a.2+f19f185a",
-    "@dedot/providers": "0.12.1-next.f19f185a.2+f19f185a",
-    "@dedot/runtime-specs": "0.12.1-next.f19f185a.2+f19f185a",
-    "@dedot/shape": "0.12.1-next.f19f185a.2+f19f185a",
-    "@dedot/types": "0.12.1-next.f19f185a.2+f19f185a",
-    "@dedot/utils": "0.12.1-next.f19f185a.2+f19f185a",
+    "@dedot/api": "0.13.0",
+    "@dedot/codecs": "0.13.0",
+    "@dedot/contracts": "0.13.0",
+    "@dedot/providers": "0.13.0",
+    "@dedot/runtime-specs": "0.13.0",
+    "@dedot/shape": "0.13.0",
+    "@dedot/types": "0.13.0",
+    "@dedot/utils": "0.13.0",
     "handlebars": "^4.7.8",
-    "prettier": "^3.4.2"
+    "prettier": "^3.5.3"
   },
   "publishConfig": {
     "access": "public",
@@ -37,7 +37,7 @@
     "node": ">=18"
   },
   "license": "Apache-2.0",
-  "gitHead": "f19f185a1d5333ab7fb64100c3010473765647ee",
+  "gitHead": "b9193d170fc63ebd64b75f37f8276a7159e2af55",
   "module": "./index.js",
   "types": "./index.d.ts",
   "exports": {

package/typink/generator/IndexGen.d.ts

@@ -1,6 +1,7 @@
 import { ContractMetadata } from '@dedot/contracts';
 import { TypesGen } from './TypesGen.js';
 export declare class IndexGen {
+    #private;
     interfaceName: string;
     contractMetadata: ContractMetadata;
     typesGen: TypesGen;

package/typink/generator/IndexGen.js

@@ -1,3 +1,4 @@
+import { ensureStorageApiSupports } from '@dedot/contracts';
 import { TypeImports } from '../../shared/index.js';
 import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
 export class IndexGen {
@@ -15,9 +16,10 @@ export class IndexGen {
         const langErrorName = this.typesGen.cleanPath(this.contractMetadata.types[langErrorId].type.path);
         const typeImports = new TypeImports();
         typeImports.addKnownType('VersionedGenericSubstrateApi', 'RpcVersion', 'RpcV2');
-        typeImports.addContractType('GenericContractApi');
+        typeImports.addContractType('GenericContractApi', 'WithLazyStorage');
         typeImports.addChainType('SubstrateApi');
         typeImports.addPortableType(langErrorName);
+        const [rootStorageName, lazyStorageName] = this.#extractRootStorageNames(typeImports);
         const { contract: { name = '', version = '', authors = [] }, source: { language = '' }, } = this.contractMetadata;
         const interfaceDocs = commentBlock([
             `@name: ${interfaceName}`, // prettier-end-here
@@ -28,6 +30,27 @@ export class IndexGen {
         ]);
         const importTypes = typeImports.toImports({ useSubPaths });
         const template = compileTemplate('typink/templates/index.hbs');
-        return beautifySourceCode(template({ interfaceName, interfaceDocs, langErrorName, importTypes }));
+        return beautifySourceCode(template({
+            interfaceName,
+            interfaceDocs,
+            langErrorName,
+            importTypes,
+            rootStorageName,
+            lazyStorageName,
+        }));
+    }
+    #extractRootStorageNames(typeImports) {
+        try {
+            ensureStorageApiSupports(this.contractMetadata.version);
+            const { ty: rootStorageId } = this.contractMetadata.storage.root;
+            const rootStorageName = this.typesGen.cleanPath(this.contractMetadata.types[rootStorageId].type.path);
+            typeImports.addPortableType(rootStorageName);
+            return [rootStorageName, `WithLazyStorage<${rootStorageName}>`];
+        }
+        catch {
+            const names = ['GenericRootStorage', 'GenericLazyStorage'];
+            typeImports.addContractType(...names);
+            return names;
+        }
     }
 }

package/typink/generator/TypesGen.d.ts

@@ -6,5 +6,6 @@ export declare class TypesGen extends BaseTypesGen {
     contractMetadata: ContractMetadata;
     constructor(contractMetadata: ContractMetadata);
     generate(useSubPaths?: boolean): Promise<string>;
+    generateType(typeId: TypeId, nestedLevel?: number, typeOut?: boolean): string;
     shouldGenerateTypeIn(id: TypeId): boolean;
 }

package/typink/generator/TypesGen.js

@@ -1,4 +1,4 @@
-import { extractContractTypes, normalizeContractTypeDef } from '@dedot/contracts';
+import { extractContractTypes, isLazyType, KnownLazyType, normalizeContractTypeDef, } from '@dedot/contracts';
 import { BaseTypesGen } from '../../shared/index.js';
 import { beautifySourceCode, compileTemplate } from '../../utils.js';
 const SKIP_TYPES = ['Result', 'Option'];
@@ -23,6 +23,33 @@ export class TypesGen extends BaseTypesGen {
         const template = compileTemplate('typink/templates/types.hbs');
         return beautifySourceCode(template({ importTypes, defTypeOut }));
     }
+    generateType(typeId, nestedLevel = 0, typeOut = false) {
+        const generatedType = super.generateType(typeId, nestedLevel, typeOut);
+        // Lazy types should be inside a wrapper structure/object
+        // So we only check for lazy type when nestedLevel > 0
+        if (nestedLevel > 0) {
+            const types = this.contractMetadata.types;
+            const typeDef = types.find(({ id }) => id == typeId);
+            const lazyType = isLazyType(typeDef.type.path);
+            if (!lazyType)
+                return generatedType;
+            const [p1, p2] = typeDef.type.params;
+            if (lazyType === KnownLazyType.LAZY) {
+                const ValueType = super.generateType(p1.type, 1, true);
+                return `{ get(): Promise<${ValueType} | undefined> }`;
+            }
+            else if (lazyType === KnownLazyType.MAPPING) {
+                const KeyType = super.generateType(p1.type, 1);
+                const ValueType = super.generateType(p2.type, 1, true);
+                return `{ get(arg: ${KeyType}): Promise<${ValueType} | undefined> }`;
+            }
+            else if (lazyType === KnownLazyType.STORAGE_VEC) {
+                const ValueType = super.generateType(p1.type, 1, true);
+                return `{ len(): Promise<number>; get(index: number): Promise<${ValueType} | undefined> }`;
+            }
+        }
+        return generatedType;
+    }
     shouldGenerateTypeIn(id) {
         const { messages, constructors } = this.contractMetadata.spec;
         return ((this.#idInParameters(id, messages) || this.#idInParameters(id, constructors)) && this.#includeKnownTypes(id));

package/typink/index.js

@@ -1,10 +1,11 @@
-import { parseRawMetadata } from '@dedot/contracts';
+import { ensureSupportedContractMetadataVersion } from '@dedot/contracts';
 import { stringDashCase, stringPascalCase } from '@dedot/utils';
 import fs from 'fs';
 import path from 'path';
-import { IndexGen, QueryGen, EventsGen, TxGen, TypesGen, ConstructorTxGen, ConstructorQueryGen, } from './generator/index.js';
+import { ConstructorQueryGen, ConstructorTxGen, EventsGen, IndexGen, QueryGen, TxGen, TypesGen, } from './generator/index.js';
 export async function generateContractTypes(metadata, contract, outDir = '.', extension = 'd.ts', useSubPaths = false) {
-    let contractMetadata = typeof metadata === 'string' ? parseRawMetadata(metadata) : metadata;
+    let contractMetadata = typeof metadata === 'string' ? JSON.parse(metadata) : metadata;
+    ensureSupportedContractMetadataVersion(contractMetadata);
     const contractName = contract || contractMetadata.contract.name;
     const dirPath = path.resolve(outDir, stringDashCase(contractName));
     const typesFileName = path.join(dirPath, `types.${extension}`);

package/typink/templates/index.hbs

@@ -15,8 +15,14 @@ export * from './types.js';
     constructorQuery: ConstructorQuery<ChainApi[Rv]>;
     constructorTx: ConstructorTx<ChainApi[Rv]>;
     events: ContractEvents<ChainApi[Rv]>;
+    storage: {
+      root(): Promise<{{{rootStorageName}}}>;
+      lazy(): {{{lazyStorageName}}};
+    };
 
     types: {
+      RootStorage: {{{rootStorageName}}};
+      LazyStorage: {{{lazyStorageName}}};
       LangError: {{{langErrorName}}};
       ChainApi: ChainApi[Rv];
     };