@dedot/codegen 0.17.0 → 0.17.1-next.6d398d60.0

package/sol/index.js

@@ -0,0 +1,35 @@
+import { stringDashCase, stringPascalCase } from '@dedot/utils';
+import fs from 'fs';
+import path from 'path';
+import { ConstructorQueryGen, ConstructorTxGen, EventsGen, IndexGen, QueryGen, TxGen, TypesGen, } from './generator/index.js';
+export async function generateSolContractTypes(abi, contract = 'contract', outDir = '.', extension = 'd.ts', useSubPaths = false) {
+    let abiItems = typeof abi === 'string' ? JSON.parse(abi) : abi;
+    const contractName = contract;
+    const dirPath = path.resolve(outDir, stringDashCase(contractName));
+    const typesFileName = path.join(dirPath, `types.${extension}`);
+    const queryTypesFileName = path.join(dirPath, `query.${extension}`);
+    const eventsTypesFileName = path.join(dirPath, `events.${extension}`);
+    const txTypesFileName = path.join(dirPath, `tx.${extension}`);
+    const constructorTxTypesFileName = path.join(dirPath, `constructor-tx.${extension}`);
+    const constructorQueryTypesFileName = path.join(dirPath, `constructor-query.${extension}`);
+    const indexTypesFileName = path.join(dirPath, `index.${extension}`);
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+    const interfaceName = `${stringPascalCase(`${contractName}`)}ContractApi`;
+    const typesGen = new TypesGen(abiItems);
+    const queryGen = new QueryGen(abiItems, typesGen);
+    const eventsGen = new EventsGen(abiItems, typesGen);
+    const txGen = new TxGen(abiItems, typesGen);
+    const constructorTxGen = new ConstructorTxGen(abiItems, typesGen);
+    const constructorQueryGen = new ConstructorQueryGen(abiItems, typesGen);
+    const indexGen = new IndexGen(interfaceName, typesGen);
+    fs.writeFileSync(typesFileName, await typesGen.generate(useSubPaths));
+    fs.writeFileSync(queryTypesFileName, await queryGen.generate(useSubPaths));
+    fs.writeFileSync(eventsTypesFileName, await eventsGen.generate(useSubPaths));
+    fs.writeFileSync(txTypesFileName, await txGen.generate(useSubPaths));
+    fs.writeFileSync(constructorQueryTypesFileName, await constructorQueryGen.generate(useSubPaths));
+    fs.writeFileSync(constructorTxTypesFileName, await constructorTxGen.generate(useSubPaths));
+    fs.writeFileSync(indexTypesFileName, await indexGen.generate(useSubPaths));
+    return { interfaceName, outputFolder: dirPath };
+}

package/typink/generator/ConstructorQueryGen.js

@@ -4,7 +4,7 @@ export class ConstructorQueryGen extends QueryGen {
     generate(useSubPaths = false) {
         this.typesGen.clearCache();
         this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
-        this.typesGen.typeImports.addContractType('GenericConstructorQuery', 'GenericConstructorQueryCall', 'GenericConstructorCallResult', 'ConstructorCallOptions', 'ContractInstantiateResult');
+        this.typesGen.typeImports.addContractType('GenericConstructorQuery', 'GenericConstructorQueryCall', 'GenericConstructorCallResult', 'ConstructorCallOptions', 'ContractInstantiateResult', 'MetadataType');
         const { constructors } = this.contractMetadata.spec;
         const constructorsOut = this.doGenerate(constructors, 'ConstructorCallOptions');
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
@@ -17,6 +17,6 @@ export class ConstructorQueryGen extends QueryGen {
         const typeOutRaw = this.typesGen.generateType(returnType.type, 0, true);
         // Unwrap langError result
         const typeOut = typeOutRaw.match(/^(\w+)<(.*), (.*)>$/).at(2);
-        return `GenericConstructorQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ConstructorCallOptions) => Promise<GenericConstructorCallResult<${typeOut}, ContractInstantiateResult<ChainApi>>>>`;
+        return `GenericConstructorQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ConstructorCallOptions) => Promise<GenericConstructorCallResult<${typeOut}, ContractInstantiateResult<ChainApi>>>, Type>`;
     }
 }

package/typink/generator/ConstructorTxGen.js

@@ -4,7 +4,7 @@ export class ConstructorTxGen extends QueryGen {
     generate(useSubPaths = false) {
         this.typesGen.clearCache();
         this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
-        this.typesGen.typeImports.addContractType('GenericConstructorTx', 'GenericConstructorTxCall', 'ConstructorTxOptions', 'GenericContractApi', 'GenericInstantiateSubmittableExtrinsic');
+        this.typesGen.typeImports.addContractType('GenericConstructorTx', 'GenericConstructorTxCall', 'ConstructorTxOptions', 'InkGenericContractApi', 'GenericInstantiateSubmittableExtrinsic', 'MetadataType');
         const { constructors } = this.contractMetadata.spec;
         const constructorsOut = this.doGenerate(constructors, 'ConstructorTxOptions');
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
@@ -13,6 +13,6 @@ export class ConstructorTxGen extends QueryGen {
     }
     generateMethodDef(def, optionsParamName = 'options') {
         const paramsOut = this.generateParamsOut(def.args);
-        return `GenericConstructorTxCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ConstructorTxOptions) => GenericInstantiateSubmittableExtrinsic<ChainApi, ContractApi>>`;
+        return `GenericConstructorTxCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ConstructorTxOptions) => GenericInstantiateSubmittableExtrinsic<ChainApi, ContractApi>, Type>`;
     }
 }

package/typink/generator/EventsGen.js

@@ -5,7 +5,7 @@ export class EventsGen extends QueryGen {
     generate(useSubPaths = false) {
         this.typesGen.clearCache();
         this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
-        this.typesGen.typeImports.addContractType('GenericContractEvents', 'GenericContractEvent');
+        this.typesGen.typeImports.addContractType('GenericContractEvents', 'GenericContractEvent', 'MetadataType');
         const { events } = this.contractMetadata.spec;
         let eventsOut = '';
         const isV5 = this.contractMetadata.version === 5;
@@ -21,7 +21,7 @@ export class EventsGen extends QueryGen {
     #generateEventDef(event) {
         const { args, label } = event;
         const paramsOut = this.generateParamsOut(args);
-        return `GenericContractEvent<'${stringPascalCase(label)}', {${paramsOut}}>`;
+        return `GenericContractEvent<'${stringPascalCase(label)}', {${paramsOut}}, Type>`;
     }
     generateParamsOut(args) {
         return args

package/typink/generator/IndexGen.js

@@ -16,7 +16,7 @@ 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', 'WithLazyStorage');
+        typeImports.addContractType('InkGenericContractApi', 'WithLazyStorage');
         typeImports.addChainType('SubstrateApi');
         typeImports.addPortableType(langErrorName);
         const [rootStorageName, lazyStorageName] = this.#extractRootStorageNames(typeImports);

package/typink/generator/QueryGen.js

@@ -11,7 +11,7 @@ export class QueryGen {
     generate(useSubPaths = false) {
         this.typesGen.clearCache();
         this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
-        this.typesGen.typeImports.addContractType('GenericContractQuery', 'GenericContractQueryCall', 'ContractCallOptions', 'GenericContractCallResult', 'ContractCallResult');
+        this.typesGen.typeImports.addContractType('GenericContractQuery', 'GenericContractQueryCall', 'ContractCallOptions', 'GenericContractCallResult', 'ContractCallResult', 'MetadataType');
         const { messages } = this.contractMetadata.spec;
         const queryCallsOut = this.doGenerate(messages, 'ContractCallOptions');
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
@@ -37,7 +37,7 @@ export class QueryGen {
         const typeOutRaw = this.typesGen.generateType(returnType.type, 0, true);
         // Unwrap langError result
         const typeOut = typeOutRaw.match(/^(\w+)<(.*), (.*)>$/).at(2);
-        return `GenericContractQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ContractCallOptions) => Promise<GenericContractCallResult<${typeOut}, ContractCallResult<ChainApi>>>>`;
+        return `GenericContractQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ContractCallOptions) => Promise<GenericContractCallResult<${typeOut}, ContractCallResult<ChainApi>>>, Type>`;
     }
     generateParamsOut(args) {
         return args

package/typink/generator/TxGen.js

@@ -4,7 +4,7 @@ export class TxGen extends QueryGen {
     generate(useSubPaths = false) {
         this.typesGen.clearCache();
         this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
-        this.typesGen.typeImports.addContractType('GenericContractTx', 'GenericContractTxCall', 'ContractTxOptions', 'ContractSubmittableExtrinsic');
+        this.typesGen.typeImports.addContractType('GenericContractTx', 'GenericContractTxCall', 'ContractTxOptions', 'ContractSubmittableExtrinsic', 'MetadataType');
         const { messages } = this.contractMetadata.spec;
         const txMessages = messages.filter((one) => one.mutates);
         const txCallsOut = this.doGenerate(txMessages, 'ContractTxOptions');
@@ -14,6 +14,6 @@ export class TxGen extends QueryGen {
     }
     generateMethodDef(def, optionsParamName = 'options') {
         const paramsOut = this.generateParamsOut(def.args);
-        return `GenericContractTxCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ContractTxOptions) => ContractSubmittableExtrinsic<ChainApi>>`;
+        return `GenericContractTxCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ContractTxOptions) => ContractSubmittableExtrinsic<ChainApi>, Type>`;
     }
 }

package/typink/templates/constructor-query.hbs

@@ -2,6 +2,6 @@
 
 {{{ importTypes }}}
 
-export interface ConstructorQuery<ChainApi extends GenericSubstrateApi> extends GenericConstructorQuery<ChainApi> {
+export interface ConstructorQuery<ChainApi extends GenericSubstrateApi, Type extends MetadataType> extends GenericConstructorQuery<ChainApi, Type> {  
     {{{ constructorsOut }}}
 }

package/typink/templates/constructor-tx.hbs

@@ -4,7 +4,8 @@
 
 export interface ConstructorTx<
   ChainApi extends GenericSubstrateApi,
-  ContractApi extends GenericContractApi = GenericContractApi,
-> extends GenericConstructorTx<ChainApi> {
+  ContractApi extends InkGenericContractApi,
+  Type extends MetadataType
+> extends GenericConstructorTx<ChainApi, Type> {
     {{{ constructorsOut }}}
 }

package/typink/templates/events.hbs

@@ -2,6 +2,6 @@
 
 {{{ importTypes }}}
 
-export interface ContractEvents<ChainApi extends GenericSubstrateApi> extends GenericContractEvents<ChainApi> {
+export interface ContractEvents <ChainApi extends GenericSubstrateApi, Type extends MetadataType> extends GenericContractEvents <ChainApi, Type> {
     {{{ eventsOut }}}
 }

package/typink/templates/index.hbs

@@ -9,21 +9,22 @@ import { ContractEvents } from './events.js';
 
 export * from './types.js';
 
-{{{interfaceDocs}}}export interface {{{interfaceName}}}<Rv extends RpcVersion = RpcVersion, ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends GenericContractApi<Rv, ChainApi> {
-    query: ContractQuery<ChainApi[Rv]>;
-    tx: ContractTx<ChainApi[Rv]>;
-    constructorQuery: ConstructorQuery<ChainApi[Rv]>;
-    constructorTx: ConstructorTx<ChainApi[Rv], {{{interfaceName}}}>;
-    events: ContractEvents<ChainApi[Rv]>;
+{{{interfaceDocs}}}export interface {{{interfaceName}}}<Rv extends RpcVersion = RpcVersion, ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends InkGenericContractApi<Rv, ChainApi> {
+    metadataType: 'ink';
+    query: ContractQuery<ChainApi[Rv], 'ink'>;
+    tx: ContractTx<ChainApi[Rv], 'ink'>;
+    constructorQuery: ConstructorQuery<ChainApi[Rv], 'ink'>;
+    constructorTx: ConstructorTx<ChainApi[Rv], {{{interfaceName}}}, 'ink'>;
+    events: ContractEvents<ChainApi[Rv], 'ink'>;
     storage: {
       root(): Promise<{{{rootStorageName}}}>;
       lazy(): {{{lazyStorageName}}};
     };
 
     types: {
+      ChainApi: ChainApi[Rv];
       RootStorage: {{{rootStorageName}}};
       LazyStorage: {{{lazyStorageName}}};
       LangError: {{{langErrorName}}};
-      ChainApi: ChainApi[Rv];
     };
 }

package/typink/templates/query.hbs

@@ -2,6 +2,6 @@
 
 {{{ importTypes }}}
 
-export interface ContractQuery<ChainApi extends GenericSubstrateApi> extends GenericContractQuery<ChainApi> {
+export interface ContractQuery<ChainApi extends GenericSubstrateApi, Type extends MetadataType> extends GenericContractQuery<ChainApi, Type> {
     {{{ queryCallsOut }}}
 }

package/typink/templates/tx.hbs

@@ -2,6 +2,6 @@
 
 {{{ importTypes }}}
 
-export interface ContractTx<ChainApi extends GenericSubstrateApi> extends GenericContractTx<ChainApi> {
+export interface ContractTx<ChainApi extends GenericSubstrateApi, Type extends MetadataType> extends GenericContractTx<ChainApi, Type> {
     {{{ txCallsOut }}}
 }