dequanto 0.1.21 → 0.1.23

package/src/gen/GeneratorFromAbi.ts

@@ -59,27 +59,36 @@ export class GeneratorFromAbi {
                 return null;
             })
             .filter(Boolean)
-            .map(x => x[ opts?.target ?? 'ts' ])
-            .map(Str.formatMethod)
-            .toArray();
+            .mapFull(arr => {
+                return {
+                    ts: arr.map(x => Str.formatMethod(x.ts)),
+                    js: arr.map(x => Str.formatMethod(x.js)),
+                    types: arr.map(x => Str.formatMethod(x.types)),
+                }
+            });
 
 
-        let methodTypes = alot(abiJson)
+        let methodTypings = alot(abiJson)
             .filter(x => x.type === 'function')
             .groupBy(x => x.name)
             .map(group => {
                 let item = group.values[0];
-                return Gen.serializeMethodTypeTs(item.name, group.values);
+                return Gen.serializeMethodTypingsTs(item.name, group.values);
             })
             .filter(Boolean)
             .toArray();
 
-        let eventsArr = abiJson
+        let eventsArr = alot(abiJson)
             .filter(x => x.type === 'event')
             .map(x => Gen.serializeEvent(x))
             .filter(Boolean)
-            .map(x => x[ opts?.target ?? 'ts' ])
-            .map(Str.formatMethod);
+            .mapFull(arr => {
+                return {
+                    ts: arr.map(x => Str.formatMethod(x.ts)),
+                    js: arr.map(x => Str.formatMethod(x.js)),
+                    types: arr.map(x => Str.formatMethod(x.types)),
+                }
+            })
 
         let eventTypes = alot(abiJson)
             .filter(x => x.type === 'event')
@@ -94,19 +103,29 @@ export class GeneratorFromAbi {
 
         //let eventInterfacesAll = Gen.serializeEventsInterfacesAllTs(abiJson.filter(x => x.type === 'event'));
 
-        let eventsExtractorsArr = abiJson
+        let eventsExtractorsArr = alot(abiJson)
             .filter(x => x.type === 'event')
             .map(x => Gen.serializeEventExtractor(x))
             .filter(Boolean)
-            .map(x => x[ opts?.target ?? 'ts' ])
-            .map(Str.formatMethod);
+            .mapFull(arr => {
+                return {
+                    ts: arr.map(x => Str.formatMethod(x.ts)),
+                    js: arr.map(x => Str.formatMethod(x.js)),
+                    types: arr.map(x => Str.formatMethod(x.types)),
+                }
+            });
 
-        let eventsFetchersArr = abiJson
+        let eventsFetchersArr = alot(abiJson)
             .filter(x => x.type === 'event')
             .map(x => Gen.serializeEventFetcher(x))
             .filter(Boolean)
-            .map(x => x[ opts?.target ?? 'ts' ])
-            .map(Str.formatMethod);
+            .mapFull(arr => {
+                return {
+                    ts: arr.map(x => Str.formatMethod(x.ts)),
+                    js: arr.map(x => Str.formatMethod(x.js)),
+                    types: arr.map(x => Str.formatMethod(x.types)),
+                }
+            });
 
         // let eventInterfaces = abiJson
         //     .filter(x => x.type === 'event')
@@ -114,15 +133,22 @@ export class GeneratorFromAbi {
         //     .filter(Boolean)
         //     .map(Str.formatMethod);
 
-        let methods = methodsArr.join('\n\n');
-        let events = eventsArr.join('\n\n');
-        let eventsExtractors = eventsExtractorsArr.join('\n\n');
-        let eventsFetchers = eventsFetchersArr.join('\n\n');
+        let methods = methodsArr[targetType].join('\n\n');
+        let methodsTypings = methodsArr.types.join('\n\n');
+        let events = eventsArr[targetType].join('\n\n');
+        let eventsTypings = eventsArr.types.join('\n\n');
+
+        let eventsExtractors = eventsExtractorsArr[targetType].join('\n\n');
+        let eventsExtractorsTypings = eventsExtractorsArr.types.join('\n\n');
+
+        let eventsFetchers = eventsFetchersArr[targetType].join('\n\n');
+        let eventsFetchersTypings = eventsFetchersArr.types.join('\n\n');
 
         let name = opts.name;
-        let templatePath = $path.resolve(`/src/gen/ContractTemplate.${ targetType }`);
+        let templatePath = $path.resolve(`/src/gen/templates/ContractTemplate.${ targetType }.tmpl`);
         let template = await File.readAsync<string>(templatePath, { skipHooks: true });
-
+        let templateDtsPath = $path.resolve(`/src/gen/templates/ContractTemplate.d.ts.tmpl`);
+        let templateDts = await File.readAsync<string>(templateDtsPath, { skipHooks: true });
 
         let EtherscanStr;
         let EthWeb3ClientStr;
@@ -130,44 +156,8 @@ export class GeneratorFromAbi {
         let sourceUri: string;
         let Web3ClientOptions = '';
         let EvmScanOptions = '';
-        let importPfx = targetType === 'js' ? 'dequanto' : '@dequanto';
+        let importPfx = true /* always */ ? 'dequanto' : '@dequanto';
         switch (opts.network) {
-            case 'bsc':
-                EtherscanStr = 'Bscscan';
-                EthWeb3ClientStr = 'BscWeb3Client';
-                imports = [
-                    `import { Bscscan } from '${importPfx}/explorer/Bscscan'`,
-                    `import { BscWeb3Client } from '${importPfx}/clients/BscWeb3Client'`,
-                ];
-                sourceUri = `https://bscscan.com/address/${opts.address}#code`;
-                break;
-            case 'polygon':
-                EtherscanStr = 'Polyscan';
-                EthWeb3ClientStr = 'PolyWeb3Client';
-                imports = [
-                    `import { Polyscan } from '${importPfx}/explorer/Polyscan'`,
-                    `import { PolyWeb3Client } from '${importPfx}/clients/PolyWeb3Client'`,
-                ];
-                sourceUri = `https://polygonscan.com/address/${opts.address}#code`;
-                break;
-            case 'xdai':
-                EtherscanStr = 'XDaiscan';
-                EthWeb3ClientStr = 'XDaiWeb3Client';
-                imports = [
-                    `import { XDaiscan } from '${importPfx}/chains/xdai/XDaiscan'`,
-                    `import { XDaiWeb3Client } from '${importPfx}/chains/xdai/XDaiWeb3Client'`,
-                ];
-                sourceUri = `https://blockscout.com/xdai/mainnet/address/${opts.address}/contracts`;
-                break;
-            case 'eth':
-                EtherscanStr = 'Etherscan';
-                EthWeb3ClientStr = 'EthWeb3Client';
-                imports = [
-                    `import { Etherscan } from '${importPfx}/explorer/Etherscan'`,
-                    `import { EthWeb3Client } from '${importPfx}/clients/EthWeb3Client'`,
-                ];
-                sourceUri = `https://etherscan.io/address/${opts.address}#code`;
-                break;
             case 'hardhat':
                 EtherscanStr = 'Etherscan';
                 EthWeb3ClientStr = 'HardhatWeb3Client';
@@ -222,6 +212,7 @@ export class GeneratorFromAbi {
         let storageReaderInitializer = '';
         let storageReaderProperty = '';
         let storageReaderClass = '';
+        let storageReaderClassTypings = '';
         try {
             let storageReaderGenerator = new GeneratorStorageReader();
             let reader = await storageReaderGenerator.generate({ ...opts, target: targetType });
@@ -231,6 +222,7 @@ export class GeneratorFromAbi {
             }
             if (reader.className) {
                 storageReaderClass = reader.code;
+                storageReaderClassTypings = reader.types;
                 storageReaderProperty = targetType === 'ts' ? `declare storage: ${reader.className}` : '';
                 storageReaderInitializer = `this.storage = new ${reader.className}(this.address, this.client, this.explorer);`;
                 $logger.log(`green<StorageReader> was generated`);
@@ -270,16 +262,46 @@ export class GeneratorFromAbi {
 
 
             .replace(`/* $EVENT_TYPES$ */`, () => Str.indent(eventTypes.map(x => x.code).join('\n'), '        '))
-            .replace(`/* $METHOD_TYPES$ */`, () => Str.indent(methodTypes.map(x => x.code).join('\n'), '        '))
+            .replace(`/* $METHOD_TYPES$ */`, () => Str.indent(methodTypings.map(x => x.code).join('\n'), '        '))
             //.replace(`/* $METHOD_INTERFACES$ */`, () => methodInterfacesArr.map(x => x.code).join('\n\n') + '\n\n' + methodInterfacesAll.code + '\n\n')
             ;
 
+        let codeDts = templateDts
+
+            .replace(`/* IMPORTS */`, () => imports.join('\n'))
+            .replace(`/* ERRORS */`, () => Gen.serializeErrors(className, abiJson))
+            .replace(/\$NAME\$/g, className)
+            .replace(`$ADDRESS$`, opts.address ? `'${opts.address}'` : 'null')
+            .replace(`/* METHODS */`, methodsTypings)
+            .replace(`/* EVENTS */`, eventsTypings)
+            .replace(`/* EVENTS_EXTRACTORS */`, eventsExtractorsTypings)
+            .replace(`/* EVENTS_FETCHERS */`, eventsFetchersTypings)
+            .replace(`$ABI$`, () => JSON.stringify(abiJson))
+            .replace(`$DATE$`, $date.format(new Date(), 'yyyy-MM-dd HH:mm'))
+            .replace(`$EXPLORER_URL$`, sourceUri)
+            //.replace(`/* $EVENT_INTERFACES$ */`, () => eventInterfaces.join('\n') + '\n\n' + eventInterfacesAll.code + '\n\n')
+
+            .replace(`/* STORAGE_READER_INITIALIZER */`, storageReaderInitializer)
+            .replace(`/* STORAGE_READER_PROPERTY */`, storageReaderProperty)
+            .replace(`/* STORAGE_READER_CLASS */`, () => storageReaderClassTypings)
+            .replace(`/* TX_CALLER_METHODS */`, () => Gen.serializeTxCallerMethods(className, abiJson)[targetType])
+            .replace(`/* TX_DATA_METHODS */`, () => Gen.serializeTxDataMethods(className, abiJson)[targetType])
+
+
+            .replace(`/* $EVENT_TYPES$ */`, () => Str.indent(eventTypes.map(x => x.code).join('\n'), '        '))
+            .replace(`/* $METHOD_TYPES$ */`, () => Str.indent(methodTypings.map(x => x.code).join('\n'), '        '))
+            ;
 
 
         await File.writeAsync(outputPath, code, { skipHooks: true });
+        if (targetType === 'js') {
+            let outputPathDts = outputPath.replace(/\.\w+$/, '.d.ts');
+            await File.writeAsync(outputPathDts, codeDts, { skipHooks: true });
+        }
+
 
         if (opts.saveAbi) {
-            let path = class_Uri.combine(opts.output, outputDirectory, `${outputFilename}.json`);
+            let path = class_Uri.combine(opts.output, outputDirectory, `${outputFilename}Abi.json`);
             await File.writeAsync(path, abiJson);
         }
 
@@ -372,7 +394,7 @@ namespace Gen {
         };
     }
 
-    export function serializeMethodTypeTs(name: string, abis: TAbiItem[]) {
+    export function serializeMethodTypingsTs(name: string, abis: TAbiItem[]) {
         let args = abis.map(abi => {
             let { fnInputArgumentsTargets } = serializeArgumentsTs(abi);
             return `[ ${fnInputArgumentsTargets.ts} ]`;
@@ -443,6 +465,9 @@ namespace Gen {
                     return this.$onLog('${abi.name}', fn);
                 }
             `,
+            types: `
+                on${abi.name} (fn?: (event: TClientEventsStreamData<TEventArguments<'${abi.name}'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'${abi.name}'>>>
+            `,
             js: `
                 on${abi.name} (fn) {
                     return this.$onLog('${abi.name}', fn);
@@ -458,6 +483,9 @@ namespace Gen {
                     return this.$extractLogs(tx, abi) as any as ITxLogItem<TEventParams<'${abi.name}'>>[];
                 }
             `,
+            types: `
+                extractLogs${abi.name} (tx: TEth.TxReceipt): ITxLogItem<TEventParams<'${abi.name}'>>[]
+            `,
             js: `
                 extractLogs${abi.name} (tx) {
                     let abi = this.$getAbiItem('event', '${abi.name}');
@@ -480,6 +508,13 @@ namespace Gen {
                     return await this.$getPastLogsParsed('${abi.name}', options) as any;
                 }
             `,
+            types: `
+                getPastLogs${abi.name} (options?: {
+                    fromBlock?: number | Date
+                    toBlock?: number | Date
+                    params?: { ${indexedParams} }
+                }): Promise<ITxLogItem<TEventParams<'${abi.name}'>>[]>
+            `,
             js: `
                 async getPastLogs${abi.name} (options) {
                     return await this.$getPastLogsParsed('${abi.name}', options);
@@ -525,6 +560,10 @@ namespace Gen {
                     return this.$read(this.$getAbiItem('function', '${abi.name}')${callInputArguments});
                 }
             `,
+            types: `
+                // ${$abiUtils.getMethodSignature(abi)}
+                ${abi.name} (${fnInputArgumentsTargets.ts}): ${fnResult}
+            `,
             js: `
                 // ${$abiUtils.getMethodSignature(abi)}
                 async ${abi.name} (${fnInputArgumentsTargets.js}) {
@@ -553,6 +592,10 @@ namespace Gen {
                     return this.$read(abi, ...args);
                 }
             `,
+            types: `
+                ${overrides}
+                ${abi.name} (...args): ${fnResult}
+            `,
             js: `
                 async ${abi.name} (...args) {
                     let abi = this.$getAbiItemOverload([ ${sigs} ], args);
@@ -575,6 +618,10 @@ namespace Gen {
                     return this.$write(this.$getAbiItem('function', '${abi.name}'), sender${callInputArguments});
                 }
             `,
+            types: `
+                // ${$abiUtils.getMethodSignature(abi)}
+                ${abi.name} (sender: TSender, ${fnInputArgumentsTargets.ts}): Promise<TxWriter>
+            `,
             js: `
                 // ${$abiUtils.getMethodSignature(abi)}
                 async ${abi.name} (sender, ${fnInputArgumentsTargets.js}) {
@@ -594,6 +641,9 @@ namespace Gen {
                     throw new Error('Not implemented. Typing purpose. Use the ContractDeployer class to deploy the contract');
                 }
             `,
+            types: `
+                $constructor (deployer: TSender, ${fnInputArgumentsTargets.ts}): Promise<TxWriter>
+            `,
             js: `
                 async $constructor (deployer, ${fnInputArgumentsTargets.js}) {
                     throw new Error('Not implemented. Typing purpose. Use the ContractDeployer class to deploy the contract');
@@ -620,6 +670,10 @@ namespace Gen {
                     return this.$write(abi, sender, ...args);
                 }
             `,
+            types: `
+                ${overrides}
+                ${abi.name} (sender: TSender, ...args): Promise<TxWriter>
+            `,
             js: `
                 async ${abi.name} (sender, ...args) {
                     let abi = this.$getAbiItemOverload([ ${sigs} ], args);

package/src/gen/GeneratorStorageReader.ts

@@ -24,7 +24,7 @@ export class GeneratorStorageReader {
             [file: string]: { content: string }
         },
         client?: Web3Client
-    }): Promise<{ code?: string, className?: string, sourcePath?: string, error?: Error }> {
+    }): Promise<{ code?: string, types?: string, className?: string, sourcePath?: string, error?: Error }> {
 
         let targetType = opts.target ?? 'ts';
         let { client, sources, contractName, address } = opts;
@@ -60,19 +60,29 @@ export class GeneratorStorageReader {
 
         let methods = this.serializeSlots(slots);
         let codeMethods = methods.map(x => x[targetType]).join('\n\n');
+        let codeMethodsTypings = methods.map(x => x.types).join('\n\n');
 
-        let templatePath = $path.resolve(`/src/gen/ContractStorageReaderTemplate.${targetType}`);
+        let templatePath = $path.resolve(`/src/gen/templates/ContractStorageReaderTemplate.${targetType}.tmpl`);
         let template = await File.readAsync<string>(templatePath, { skipHooks: true });
+
+        let templateTypingsPath = $path.resolve(`/src/gen/templates/ContractStorageReaderTemplate.d.ts.tmpl`);
+        let templateTypings = await File.readAsync<string>(templateTypingsPath, { skipHooks: true });
+
         let className = $gen.toClassName(opts.name + 'StorageReader');
         let code = template
             .replace(`$NAME$`, className)
             .replace(`/* METHODS */`, () => codeMethods)
             .replace(`$SLOTS$`, () => JSON.stringify(slots, null, '    '))
 
+        let codeTypings = templateTypings
+            .replace(`$NAME$`, className)
+            .replace(`/* METHODS */`, () => codeMethodsTypings)
+            .replace(`$SLOTS$`, () => JSON.stringify(slots, null, '    '))
 
         return {
             className: className,
             code: code,
+            types: codeTypings,
             sourcePath: file.path
         };
     }
@@ -84,6 +94,7 @@ export class GeneratorStorageReader {
                 return {
                     ts: Str.formatMethod(entry.ts),
                     js: Str.formatMethod(entry.js),
+                    types: Str.formatMethod(entry.types),
                 }
             });
     }
@@ -98,6 +109,9 @@ export class GeneratorStorageReader {
                     return this.$storage.get(['${name}', ${ parametersCall ?? '' }]);
                 }
             `,
+            types: `
+                ${name}(${parametersTypes?.ts ?? ''}): Promise<${returnType}>
+            `,
             js: `
                 async ${name}(${parametersTypes?.js ?? ''}) {
                     return this.$storage.get(['${name}', ${ parametersCall ?? '' }]);

package/src/gen/templates/ContractStorageReaderTemplate.d.ts.tmpl

@@ -0,0 +1,7 @@
+declare class $NAME$ extends ContractStorageReaderBase {
+
+/* METHODS */
+
+    $slots: $SLOTS$
+
+}

package/src/gen/templates/ContractTemplate.d.ts.tmpl

@@ -0,0 +1,110 @@
+/**
+ *  AUTO-Generated Class: $DATE$
+ *  Implementation: $EXPLORER_URL$
+ */
+import di from 'a-di';
+import { TAddress } from 'dequanto/models/TAddress';
+import { TAccount } from 'dequanto/models/TAccount';
+import { TBufferLike } from 'dequanto/models/TBufferLike';
+import { ClientEventsStream, TClientEventsStreamData } from 'dequanto/clients/ClientEventsStream';
+import { ContractBase } from 'dequanto/contracts/ContractBase';
+import { ContractBaseUtils } from 'dequanto/contracts/utils/ContractBaseUtils';
+import { ContractStorageReaderBase } from 'dequanto/contracts/ContractStorageReaderBase';
+import { TxWriter } from 'dequanto/txs/TxWriter';
+import { ITxLogItem } from 'dequanto/txs/receipt/ITxLogItem';
+import { Web3Client } from 'dequanto/clients/Web3Client';
+import { IBlockChainExplorer } from 'dequanto/explorer/IBlockChainExplorer';
+import { SubjectStream } from 'dequanto/class/SubjectStream';
+
+
+import type { ContractWriter } from 'dequanto/contracts/ContractWriter';
+import type { TAbiItem } from 'dequanto/types/TAbi';
+import type { TEth } from 'dequanto/models/TEth';
+import type { TOverrideReturns } from 'dequanto/utils/types';
+
+
+/* IMPORTS */
+
+/* ERRORS */
+
+export declare class $NAME$ extends ContractBase {
+
+
+    Types: T$NAME$Types;
+
+
+
+/* METHODS */
+
+    $call (): I$NAME$TxCaller
+    $signed (): TOverrideReturns<I$NAME$TxCaller, Promise<{ signed: TEth.Hex, error?: Error & { data?: { type: string, params } } }>>
+    $data (): I$NAME$TxData
+    $gas (): TOverrideReturns<I$NAME$TxCaller, Promise<{ gas?: bigint, price?: bigint, error?: Error & { data?: { type: string, params } } }>>
+
+    onTransaction <TMethod extends keyof T$NAME$Types['Methods']> (method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
+        tx: TEth.Tx
+        block: TEth.Block<TEth.Hex>
+        calldata: {
+            method: TMethod
+            arguments: T$NAME$Types['Methods'][TMethod]['arguments']
+        }
+    }>
+
+    onLog (event: keyof TEvents, cb?: (event: TClientEventsStreamData) => void): ClientEventsStream<TClientEventsStreamData>
+
+
+    getPastLogs <TEventName extends keyof TEvents> (
+        events: TEventName[], options?: TEventLogOptions<TEventParams<TEventName>>
+    ): Promise<ITxLogItem<TEventParams<TEventName>, TEventName>[]>
+
+    getPastLogs <TEventName extends keyof TEvents> (
+        event: TEventName, options?: TEventLogOptions<TEventParams<TEventName>>
+    ): Promise<ITxLogItem<TEventParams<TEventName>, TEventName>[]>
+
+    getPastLogs (mix: any, options?): Promise<any>
+
+/* EVENTS */
+
+/* EVENTS_EXTRACTORS */
+
+/* EVENTS_FETCHERS */
+
+    abi: TAbiItem[]
+
+    /* STORAGE_READER_PROPERTY */
+}
+
+type TSender = TAccount & {
+    value?: string | number | bigint
+}
+
+type TEventLogOptions<TParams> = {
+    fromBlock?: number | Date
+    toBlock?: number | Date
+    params?: TParams
+}
+
+export type T$NAME$Types = {
+    Events: {
+/* $EVENT_TYPES$ */
+    },
+    Methods: {
+/* $METHOD_TYPES$ */
+    }
+}
+
+/* STORAGE_READER_CLASS */
+
+interface I$NAME$TxCaller {
+/* TX_CALLER_METHODS */
+}
+
+
+interface I$NAME$TxData {
+/* TX_DATA_METHODS */
+}
+
+
+type TEvents = T$NAME$Types['Events'];
+type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
+type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;