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

package/cjs/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/cjs/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/cjs/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 }}}
 }

package/index.d.ts

@@ -1,3 +1,4 @@
 export * from './types.js';
 export * from './chaintypes/index.js';
 export * from './typink/index.js';
+export * from './sol/index.js';

package/index.js

@@ -1,3 +1,4 @@
 export * from './types.js';
 export * from './chaintypes/index.js';
 export * from './typink/index.js';
+export * from './sol/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/codegen",
-  "version": "0.17.0",
+  "version": "0.17.1-next.6d398d60.0+6d398d60",
   "description": "Generate types",
   "author": "Thang X. Vu <thang@dedot.dev>",
   "homepage": "https://dedot.dev",
@@ -14,18 +14,19 @@
   "type": "module",
   "scripts": {
     "build": "tsc --project tsconfig.build.json && tsc --project tsconfig.build.cjs.json && yarn copy",
+    "test": "npx vitest --watch=false",
     "clean": "rm -rf ./dist && rm -rf ./tsconfig.tsbuildinfo ./tsconfig.build.tsbuildinfo",
     "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.17.0",
-    "@dedot/codecs": "0.17.0",
-    "@dedot/contracts": "0.17.0",
-    "@dedot/providers": "0.17.0",
-    "@dedot/runtime-specs": "0.17.0",
-    "@dedot/shape": "0.17.0",
-    "@dedot/types": "0.17.0",
-    "@dedot/utils": "0.17.0",
+    "@dedot/api": "0.17.1-next.6d398d60.0+6d398d60",
+    "@dedot/codecs": "0.17.1-next.6d398d60.0+6d398d60",
+    "@dedot/contracts": "0.17.1-next.6d398d60.0+6d398d60",
+    "@dedot/providers": "0.17.1-next.6d398d60.0+6d398d60",
+    "@dedot/runtime-specs": "0.17.1-next.6d398d60.0+6d398d60",
+    "@dedot/shape": "0.17.1-next.6d398d60.0+6d398d60",
+    "@dedot/types": "0.17.1-next.6d398d60.0+6d398d60",
+    "@dedot/utils": "0.17.1-next.6d398d60.0+6d398d60",
     "handlebars": "^4.7.8",
     "prettier": "^3.6.2"
   },
@@ -37,7 +38,7 @@
     "node": ">=18"
   },
   "license": "Apache-2.0",
-  "gitHead": "77e751248ad7bca0cb374e17e65afef791fb3e4d",
+  "gitHead": "6d398d6002387fa7e78ca6df194e5f30595a6be8",
   "module": "./index.js",
   "types": "./index.d.ts",
   "exports": {

package/sol/generator/ConstructorQueryGen.d.ts

@@ -0,0 +1,12 @@
+import { TypesGen } from '@dedot/codegen/sol/generator/TypesGen';
+import { SolAbi, SolAbiConstructor } from '@dedot/contracts';
+export declare class ConstructorQueryGen {
+    readonly abi: SolAbi;
+    readonly typesGen: TypesGen;
+    constructor(abi: SolAbi, typesGen: TypesGen);
+    generate(useSubPaths?: boolean): Promise<string>;
+    doGenerateConstructorFragment(abiItem: SolAbiConstructor, optionsTypeName?: string): string;
+    generateMethodDef(abiItem: SolAbiConstructor, optionsParamName?: string): string;
+    generateParamsOut(abiItem: SolAbiConstructor): string;
+    protected findConstructor(): SolAbiConstructor;
+}

package/sol/generator/ConstructorQueryGen.js

@@ -0,0 +1,51 @@
+import { stringCamelCase } from '@dedot/utils';
+import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
+export class ConstructorQueryGen {
+    abi;
+    typesGen;
+    constructor(abi, typesGen) {
+        this.abi = abi;
+        this.typesGen = typesGen;
+    }
+    generate(useSubPaths = false) {
+        this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
+        this.typesGen.typeImports.addContractType('GenericConstructorQuery', 'GenericConstructorQueryCall', 'GenericConstructorCallResult', 'ConstructorCallOptions', 'ContractInstantiateResult', 'MetadataType');
+        let constructor = this.findConstructor();
+        const constructorsOut = this.doGenerateConstructorFragment(constructor, 'ConstructorCallOptions');
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = compileTemplate('sol/templates/constructor-query.hbs');
+        return beautifySourceCode(template({ importTypes, constructorsOut }));
+    }
+    doGenerateConstructorFragment(abiItem, optionsTypeName) {
+        let callsOut = '';
+        const { inputs = [] } = abiItem;
+        // In case there is an arg has label `options`,
+        // we use the name `_options` for the last options param
+        // This is just and edge case, so this approach works for now
+        const optionsParamName = inputs.some(({ name }) => name === 'options') ? '_options' : 'options';
+        callsOut += `${commentBlock(inputs.map((input, idx) => `@param {${this.typesGen.generateType(input, abiItem, 1)}} ${stringCamelCase(input.name || `arg${idx}`)}`), optionsTypeName ? `@param {${optionsTypeName}} ${optionsParamName}` : '')}`;
+        callsOut += `new: ${this.generateMethodDef(abiItem, optionsParamName)};\n\n`;
+        return callsOut;
+    }
+    generateMethodDef(abiItem, optionsParamName = 'options') {
+        const paramsOut = this.generateParamsOut(abiItem);
+        return `GenericConstructorQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ConstructorCallOptions) => Promise<GenericConstructorCallResult<[], ContractInstantiateResult<ChainApi>>>, Type>`;
+    }
+    generateParamsOut(abiItem) {
+        return abiItem.inputs
+            .map((input, idx) => `${stringCamelCase(input.name || `arg${idx}`)}: ${this.typesGen.generateType(input, abiItem, 1)}`)
+            .join(', ');
+    }
+    findConstructor() {
+        let constructor = this.abi.find((item) => item.type === 'constructor');
+        // Fallback to default constructor
+        if (!constructor) {
+            constructor = {
+                inputs: [],
+                stateMutability: 'nonpayable',
+                type: 'constructor',
+            };
+        }
+        return constructor;
+    }
+}

package/sol/generator/ConstructorTxGen.d.ts

@@ -0,0 +1,6 @@
+import { SolAbiConstructor } from '@dedot/contracts';
+import { ConstructorQueryGen } from './ConstructorQueryGen.js';
+export declare class ConstructorTxGen extends ConstructorQueryGen {
+    generate(useSubPaths?: boolean): Promise<string>;
+    generateMethodDef(abiItem: SolAbiConstructor, optionsParamName?: string): string;
+}

package/sol/generator/ConstructorTxGen.js

@@ -0,0 +1,17 @@
+import { beautifySourceCode, compileTemplate } from '../../utils.js';
+import { ConstructorQueryGen } from './ConstructorQueryGen.js';
+export class ConstructorTxGen extends ConstructorQueryGen {
+    generate(useSubPaths = false) {
+        this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
+        this.typesGen.typeImports.addContractType('GenericConstructorTx', 'SolGenericContractApi', 'GenericConstructorTxCall', 'ConstructorTxOptions', 'GenericInstantiateSubmittableExtrinsic', 'MetadataType');
+        let constructor = this.findConstructor();
+        const constructorsOut = this.doGenerateConstructorFragment(constructor, 'ConstructorTxOptions');
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = compileTemplate('sol/templates/constructor-tx.hbs');
+        return beautifySourceCode(template({ importTypes, constructorsOut }));
+    }
+    generateMethodDef(abiItem, optionsParamName = 'options') {
+        const paramsOut = this.generateParamsOut(abiItem);
+        return `GenericConstructorTxCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ConstructorTxOptions) => GenericInstantiateSubmittableExtrinsic<ChainApi, ContractApi>, Type>`;
+    }
+}

package/sol/generator/EventsGen.d.ts

@@ -0,0 +1,10 @@
+import { SolAbi, SolAbiEvent } from '@dedot/contracts';
+import { TypesGen } from './TypesGen.js';
+export declare class EventsGen {
+    #private;
+    readonly abi: SolAbi;
+    readonly typesGen: TypesGen;
+    constructor(abi: SolAbi, typesGen: TypesGen);
+    generate(useSubPaths?: boolean): Promise<string>;
+    generateParamsOut(abiItem: SolAbiEvent): string;
+}

package/sol/generator/EventsGen.js

@@ -0,0 +1,34 @@
+import { stringCamelCase, stringPascalCase } from '@dedot/utils';
+import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
+export class EventsGen {
+    abi;
+    typesGen;
+    constructor(abi, typesGen) {
+        this.abi = abi;
+        this.typesGen = typesGen;
+    }
+    generate(useSubPaths = false) {
+        this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
+        this.typesGen.typeImports.addContractType('GenericContractEvents', 'GenericContractEvent', 'MetadataType');
+        const events = this.abi.filter((o) => o.type === 'event');
+        let eventsOut = '';
+        events.forEach((event) => {
+            const { name, anonymous } = event;
+            eventsOut += `${stringPascalCase(name)}: ${this.#generateEventDef(event)};\n\n`;
+        });
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = compileTemplate('sol/templates/events.hbs');
+        return beautifySourceCode(template({ importTypes, eventsOut }));
+    }
+    #generateEventDef(abiItem) {
+        const { name } = abiItem;
+        const paramsOut = this.generateParamsOut(abiItem);
+        return `GenericContractEvent<'${stringPascalCase(name)}', {${paramsOut}}, Type>`;
+    }
+    generateParamsOut(abiItem) {
+        const { inputs } = abiItem;
+        return inputs
+            .map((o, idx) => `${commentBlock(`@indexed: ${o.indexed}`)}${stringCamelCase(o.name || `arg${idx}`)}: ${this.typesGen.generateType(o, abiItem, 1)}`)
+            .join(', ');
+    }
+}

package/sol/generator/IndexGen.d.ts

@@ -0,0 +1,7 @@
+import { TypesGen } from './TypesGen.js';
+export declare class IndexGen {
+    interfaceName: string;
+    typesGen: TypesGen;
+    constructor(interfaceName: string, typesGen: TypesGen);
+    generate(useSubPaths?: boolean): Promise<string>;
+}

package/sol/generator/IndexGen.js

@@ -0,0 +1,23 @@
+import { TypeImports } from '../../shared/index.js';
+import { beautifySourceCode, compileTemplate } from '../../utils.js';
+export class IndexGen {
+    interfaceName;
+    typesGen;
+    constructor(interfaceName, typesGen) {
+        this.interfaceName = interfaceName;
+        this.typesGen = typesGen;
+    }
+    generate(useSubPaths = false) {
+        const interfaceName = this.interfaceName;
+        const typeImports = new TypeImports();
+        typeImports.addKnownType('VersionedGenericSubstrateApi', 'RpcVersion', 'RpcV2');
+        typeImports.addContractType('SolGenericContractApi', 'SolRegistry');
+        typeImports.addChainType('SubstrateApi');
+        const importTypes = typeImports.toImports({ useSubPaths });
+        const template = compileTemplate('sol/templates/index.hbs');
+        return beautifySourceCode(template({
+            interfaceName,
+            importTypes,
+        }));
+    }
+}

package/sol/generator/QueryGen.d.ts

@@ -0,0 +1,11 @@
+import { SolAbi, SolAbiFunction } from '@dedot/contracts';
+import { TypesGen } from './TypesGen.js';
+export declare class QueryGen {
+    readonly abi: SolAbi;
+    readonly typesGen: TypesGen;
+    constructor(abi: SolAbi, typesGen: TypesGen);
+    generate(useSubPaths?: boolean): Promise<string>;
+    doGenerate(functions: SolAbiFunction[], optionsTypeName?: string): string;
+    generateMethodDef(abiItem: SolAbiFunction, optionsParamName?: string): string;
+    generateParamsOut(abiItem: SolAbiFunction): string;
+}

package/sol/generator/QueryGen.js

@@ -0,0 +1,46 @@
+import { normalizeLabel } from '@dedot/contracts';
+import { stringCamelCase } from '@dedot/utils';
+import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
+export class QueryGen {
+    abi;
+    typesGen;
+    constructor(abi, typesGen) {
+        this.abi = abi;
+        this.typesGen = typesGen;
+    }
+    generate(useSubPaths = false) {
+        this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
+        this.typesGen.typeImports.addContractType('GenericContractQuery', 'GenericContractQueryCall', 'ContractCallOptions', 'GenericContractCallResult', 'ContractCallResult', 'MetadataType');
+        const functions = this.abi.filter((item) => item.type === 'function');
+        const queryCallsOut = this.doGenerate(functions, 'ContractCallOptions');
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = compileTemplate('sol/templates/query.hbs');
+        return beautifySourceCode(template({ importTypes, queryCallsOut }));
+    }
+    doGenerate(functions, optionsTypeName) {
+        let callsOut = '';
+        functions.forEach((def) => {
+            const { inputs, name } = def;
+            // In case there is an arg has label `options`,
+            // we use the name `_options` for the last options param
+            // This is just and edge case, so this approach works for now
+            const optionsParamName = inputs.some(({ name }) => name === 'options') ? '_options' : 'options';
+            callsOut += `${commentBlock(inputs.map((input, idx) => `@param {${this.typesGen.generateType(input, def, 1)}} ${stringCamelCase(input.name || `arg${idx}`)}`), optionsTypeName ? `@param {${optionsTypeName}} ${optionsParamName}` : '')}`;
+            callsOut += `${normalizeLabel(name)}: ${this.generateMethodDef(def, optionsParamName)};\n\n`;
+        });
+        return callsOut;
+    }
+    generateMethodDef(abiItem, optionsParamName = 'options') {
+        const { outputs } = abiItem;
+        const paramsOut = this.generateParamsOut(abiItem);
+        const typeOutInner = `${outputs.map((o) => this.typesGen.generateType(o, abiItem, 1, true)).join(',')}`;
+        // If there is only one output, we don't need to wrap it in a tuple, for user-friendly
+        const typeOut = outputs.length === 1 ? typeOutInner : `[${typeOutInner}]`;
+        return `GenericContractQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ContractCallOptions) => Promise<GenericContractCallResult<${typeOut}, ContractCallResult<ChainApi>>>, Type>`;
+    }
+    generateParamsOut(abiItem) {
+        return abiItem.inputs
+            .map((input, idx) => `${stringCamelCase(input.name || `arg${idx}`)}: ${this.typesGen.generateType(input, abiItem, 1)}`)
+            .join(', ');
+    }
+}

package/sol/generator/TxGen.d.ts

@@ -0,0 +1,6 @@
+import { SolAbiFunction } from '@dedot/contracts';
+import { QueryGen } from './QueryGen.js';
+export declare class TxGen extends QueryGen {
+    generate(useSubPaths?: boolean): Promise<string>;
+    generateMethodDef(abiItem: SolAbiFunction, optionsParamName?: string): string;
+}

package/sol/generator/TxGen.js

@@ -0,0 +1,17 @@
+import { beautifySourceCode, compileTemplate } from '../../utils.js';
+import { QueryGen } from './QueryGen.js';
+export class TxGen extends QueryGen {
+    generate(useSubPaths = false) {
+        this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
+        this.typesGen.typeImports.addContractType('GenericContractTx', 'GenericContractTxCall', 'ContractTxOptions', 'ContractSubmittableExtrinsic', 'MetadataType');
+        const txFunctions = this.abi.filter((item) => item.type === 'function' && item.stateMutability !== 'view');
+        const txCallsOut = this.doGenerate(txFunctions, 'ContractTxOptions');
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = compileTemplate('sol/templates/tx.hbs');
+        return beautifySourceCode(template({ importTypes, txCallsOut }));
+    }
+    generateMethodDef(abiItem, optionsParamName = 'options') {
+        const paramsOut = this.generateParamsOut(abiItem);
+        return `GenericContractTxCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ContractTxOptions) => ContractSubmittableExtrinsic<ChainApi>, Type>`;
+    }
+}

package/sol/generator/TypesGen.d.ts

@@ -0,0 +1,15 @@
+import { SolAbi, SolAbiItem, SolAbiTypeDef } from '@dedot/contracts';
+import { TypeImports } from '../../shared/TypeImports.js';
+export declare const SUPPORTED_SOLIDITY_TYPES: RegExp[];
+export declare const BASIC_KNOWN_TYPES: RegExp[];
+export declare class TypesGen {
+    #private;
+    readonly abi: SolAbi;
+    typeImports: TypeImports;
+    constructor(abi: SolAbi);
+    generate(useSubPaths?: boolean): Promise<string>;
+    generateTypeName(typeDef: SolAbiTypeDef, abiItem: SolAbiItem, typeOut?: boolean): string;
+    generateType(typeDef: SolAbiTypeDef, abiItem?: SolAbiItem, nestedLevel?: number, typeOut?: boolean): string;
+    generateObjectType(components: SolAbiTypeDef[], nestedLevel?: number, typeOut?: boolean): string;
+    addTypeImport(typeName: string | string[]): void;
+}

package/sol/generator/TypesGen.js

@@ -0,0 +1,212 @@
+import { stringPascalCase } from '@dedot/utils';
+import { TypeImports } from '../../shared/TypeImports.js';
+import { beautifySourceCode, compileTemplate, isNativeType } from '../../utils.js';
+const INT_TYPES = /^int(\d+)?(\[(\d+)?])*?$/;
+const UINT_TYPES = /^uint(\d+)?(\[(\d+)?])*?$/;
+const BYTES_TYPES = /^bytes(\d+)?(\[(\d+)?])*?$/;
+const FIXED_TYPES = /^fixed(\d+x\d+)?(\[(\d+)?])*?$/;
+const UNFIXED_TYPES = /^ufixed(\d+x\d+)?(\[(\d+)?])*?$/;
+const STRING_TYPES = /^string(\[(\d+)?])*?$/;
+const BOOL_TYPES = /^bool(\[(\d+)?])*?$/;
+const ADDRESS_TYPES = /^address(\[(\d+)?])*?$/;
+const FUNCTION_TYPES = /^function(\[(\d+)?])*?$/;
+const COMPONENT_TYPES = /^tuple(\[(\d+)?])*?$/;
+const ARRAY_DIM = /\[(\d+)?]/g;
+const ONLY_ARRAY_DIM = /^\[(\d+)?]$/;
+export const SUPPORTED_SOLIDITY_TYPES = [
+    INT_TYPES,
+    UINT_TYPES,
+    BYTES_TYPES,
+    FIXED_TYPES,
+    UNFIXED_TYPES,
+    STRING_TYPES,
+    BOOL_TYPES,
+    ADDRESS_TYPES,
+    FUNCTION_TYPES,
+    COMPONENT_TYPES,
+];
+export const BASIC_KNOWN_TYPES = [
+    /^(H160)$/,
+    /^(FixedBytes)<(\d+)>$/,
+    /^(Bytes)$/,
+    /^(BytesLike)$/,
+    /^(Fixed)<(\d+),(\d+)>$/,
+    /^(UFixed)<(\d+),(\d+)>$/,
+    /^(FixedArray)$/,
+];
+export class TypesGen {
+    abi;
+    typeImports;
+    constructor(abi) {
+        this.abi = abi;
+        this.typeImports = new TypeImports();
+    }
+    generate(useSubPaths = false) {
+        let defTypeOut = '';
+        this.abi.forEach((abiItem) => {
+            if (abiItem.type === 'fallback' || abiItem.type === 'receive')
+                return;
+            if (abiItem.type === 'function' || abiItem.type === 'constructor' || abiItem.type === 'event') {
+                const { inputs } = abiItem;
+                inputs
+                    .filter((o) => o.components && o.components.length > 0)
+                    .forEach((o) => {
+                    defTypeOut += `export type ${this.generateTypeName(o, abiItem)} = ${this.generateType(o, abiItem, 0)};\n\n`;
+                });
+            }
+            if (abiItem.type === 'function') {
+                const { outputs } = abiItem;
+                outputs
+                    .filter((o) => o.components && o.components.length > 0)
+                    .forEach((o) => {
+                    defTypeOut += `export type ${this.generateTypeName(o, abiItem, true)} = ${this.generateType(o, abiItem, 0, true)};\n\n`;
+                });
+            }
+        });
+        const importTypes = this.typeImports.toImports({ excludeModules: ['./types.js'], useSubPaths });
+        const template = compileTemplate('sol/templates/types.hbs');
+        return beautifySourceCode(template({ importTypes, defTypeOut }));
+    }
+    generateTypeName(typeDef, abiItem, typeOut = false) {
+        if (abiItem.type === 'fallback' || abiItem.type === 'receive')
+            return '';
+        if (COMPONENT_TYPES.test(typeDef.type)) {
+            const baseName = abiItem.type === 'constructor'
+                ? `${typeDef.name}_input`
+                : `${abiItem.name}_${typeDef.name}_${typeOut ? 'output' : 'input'}`;
+            return stringPascalCase(baseName);
+        }
+        return '';
+    }
+    generateType(typeDef, abiItem, nestedLevel = 0, typeOut = false) {
+        if (nestedLevel > 0 && abiItem) {
+            let typeName = this.generateTypeName(typeDef, abiItem, typeOut);
+            if (typeName.length === 0) {
+                typeName = this.#generateType(typeDef, nestedLevel, typeOut);
+                return typeName;
+            }
+            this.addTypeImport(typeName);
+            return typeName;
+        }
+        return this.#generateType(typeDef, nestedLevel, typeOut);
+    }
+    #generateType(typeDef, nestedLevel = 0, typeOut = false) {
+        const { type } = typeDef;
+        let baseType = this.#generateBaseType(typeDef, nestedLevel, typeOut);
+        if (!COMPONENT_TYPES.test(type)) {
+            // baseType of component types are all generated types, eg: { a: bigint, b: string }
+            // So we don't import them here.
+            this.addTypeImport(baseType);
+        }
+        // Match all array dimensions
+        const dimensions = type.match(ARRAY_DIM);
+        dimensions
+            // Match each dimension to see if fixed array or dynamic array (eg: [3] vs [])
+            ?.map((o) => o.match(ONLY_ARRAY_DIM))
+            .forEach(([_, n]) => {
+            if (n) {
+                this.addTypeImport('FixedArray');
+                baseType = `FixedArray<${baseType}, ${n}>`;
+            }
+            else {
+                baseType = isNativeType(baseType.replaceAll('[]', '')) ? `${baseType}[]` : `Array<${baseType}>`;
+            }
+        });
+        return baseType;
+    }
+    #generateBaseType(typeDef, nestedLevel = 0, typeOut = false) {
+        const { type } = typeDef;
+        if (INT_TYPES.test(type)) {
+            const [_, bitsStr] = type.match(INT_TYPES);
+            // Default to 256 when unspecified
+            const bits = bitsStr ? parseInt(bitsStr) : 256;
+            const isSafeNumber = bits <= 48;
+            return isSafeNumber ? `number` : 'bigint';
+        }
+        else if (UINT_TYPES.test(type)) {
+            const [_, bitsStr] = type.match(UINT_TYPES);
+            // Default to 256 when unspecified
+            const bits = bitsStr ? parseInt(bitsStr) : 256;
+            const isSafeNumber = bits <= 48;
+            return isSafeNumber ? `number` : 'bigint';
+        }
+        else if (BYTES_TYPES.test(type)) {
+            const [_, n] = type.match(BYTES_TYPES);
+            if (n) {
+                return `FixedBytes<${n}>`;
+            }
+            if (typeOut) {
+                return `Bytes`;
+            }
+            return `BytesLike`;
+        }
+        else if (BOOL_TYPES.test(type)) {
+            return 'boolean';
+        }
+        else if (STRING_TYPES.test(type)) {
+            return 'string';
+        }
+        else if (COMPONENT_TYPES.test(type)) {
+            const { components = [] } = typeDef;
+            if (components.length === 0) {
+                return '[]';
+            }
+            else {
+                const objectType = this.generateObjectType(components, nestedLevel + 1, typeOut);
+                return `${objectType}`;
+            }
+        }
+        else if (ADDRESS_TYPES.test(type)) {
+            return `H160`;
+        }
+        else if (FUNCTION_TYPES.test(type)) {
+            // Function type is an address (20 bytes) followed by a function selector (4 bytes).
+            // Ref: https://docs.soliditylang.org/en/latest/abi-spec.html#:~:text=function%3A%20an%20address%20(20%20bytes)%20followed%20by%20a%20function%20selector%20(4%20bytes).%20Encoded%20identical%20to%20bytes24.
+            return `FixedBytes<24>`;
+        }
+        else if (FIXED_TYPES.test(type)) {
+            const [_, denotation] = type.match(FIXED_TYPES);
+            // Ref: https://docs.soliditylang.org/en/latest/abi-spec.html#:~:text=fixed%2C%20ufixed%3A%20synonyms%20for%20fixed128x18%2C%20ufixed128x18%20respectively.%20For%20computing%20the%20function%20selector%2C%20fixed128x18%20and%20ufixed128x18%20have%20to%20be%20used.
+            const [m, n] = denotation ? denotation.split('x').map((s) => parseInt(s)) : [128, 18];
+            return `Fixed<${m},${n}>`;
+        }
+        else if (UNFIXED_TYPES.test(type)) {
+            const [_, denotation] = type.match(UNFIXED_TYPES);
+            // Ref: https://docs.soliditylang.org/en/latest/abi-spec.html#:~:text=fixed%2C%20ufixed%3A%20synonyms%20for%20fixed128x18%2C%20ufixed128x18%20respectively.%20For%20computing%20the%20function%20selector%2C%20fixed128x18%20and%20ufixed128x18%20have%20to%20be%20used.
+            const [m, n] = denotation ? denotation.split('x').map((s) => parseInt(s)) : [128, 18];
+            return `UFixed<${m},${n}>`;
+        }
+        else {
+            throw new Error(`Unsupported Solidity type: ${type}`);
+        }
+    }
+    generateObjectType(components, nestedLevel = 0, typeOut = false) {
+        const props = components.map((typeDef) => {
+            const type = this.generateType(typeDef, undefined, nestedLevel + 1, typeOut);
+            return {
+                name: typeDef.name,
+                type,
+            };
+        });
+        if (props.length > 0 && props.at(0).name.length === 0) {
+            return `[${props.map(({ type }) => `${type}`).join(', ')}]`;
+        }
+        return `{${props.map(({ name, type }) => `${name}: ${type}`).join(',\n')}}`;
+    }
+    addTypeImport(typeName) {
+        if (Array.isArray(typeName)) {
+            typeName.forEach((one) => this.addTypeImport(one));
+            return;
+        }
+        if (isNativeType(typeName)) {
+            return;
+        }
+        const re = BASIC_KNOWN_TYPES.find((re) => typeName.match(re));
+        if (re) {
+            const typeBase = typeName.match(re)[1];
+            this.typeImports.addCodecType(typeBase);
+            return;
+        }
+        this.typeImports.addPortableType(typeName);
+    }
+}

package/sol/generator/index.d.ts

@@ -0,0 +1,7 @@
+export * from './IndexGen.js';
+export * from './QueryGen.js';
+export * from './TypesGen.js';
+export * from './TxGen.js';
+export * from './ConstructorTxGen.js';
+export * from './ConstructorQueryGen.js';
+export * from './EventsGen.js';

package/sol/generator/index.js

@@ -0,0 +1,7 @@
+export * from './IndexGen.js';
+export * from './QueryGen.js';
+export * from './TypesGen.js';
+export * from './TxGen.js';
+export * from './ConstructorTxGen.js';
+export * from './ConstructorQueryGen.js';
+export * from './EventsGen.js';

package/sol/index.d.ts

@@ -0,0 +1,3 @@
+import { SolAbi } from '@dedot/contracts';
+import { GeneratedResult } from '../types.js';
+export declare function generateSolContractTypes(abi: SolAbi | string, contract?: string | undefined, outDir?: string, extension?: string, useSubPaths?: boolean): Promise<GeneratedResult>;