dequanto 0.0.1 → 0.0.7

package/src/gen/GeneratorFromAbi.ts

@@ -1,13 +1,19 @@
+import alot from 'alot';
+import { type AbiItem } from 'web3-utils';
 import { TAddress } from '@dequanto/models/TAddress';
-import { AbiItem } from 'web3-utils';
 import { File } from 'atma-io';
 import { class_Uri } from 'atma-utils';
-import alot from 'alot';
 import { $abiType } from '@dequanto/utils/$abiType';
 import { $date } from '@dequanto/utils/$date';
 import { $path } from '@dequanto/utils/$path';
 import { $abiUtils } from '@dequanto/utils/$abiUtils';
 import { TPlatform } from '@dequanto/models/TPlatform';
+import { $config } from '@dequanto/utils/$config';
+import { $logger } from '@dequanto/utils/$logger';
+import { GeneratorStorageReader } from './GeneratorStorageReader';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { Str } from './utils/Str';
+import { $gen } from './utils/$gen';
 
 export class GeneratorFromAbi {
 
@@ -18,25 +24,46 @@ export class GeneratorFromAbi {
     async generate (abiJson: AbiItem[], opts: {
         network: TPlatform
         name: string
+        contractName: string
         address: TAddress
         output: string
         implementation: TAddress
         saveAbi?: boolean
         sources?: {
             [file: string]: { content: string }
-        }
+        },
+        client?: Web3Client
     }) {
 
-        let methodsArr = abiJson
-            .map(item => {
-                if (item.type === 'function') {
+        let methodsArr = alot(abiJson)
+            .filter(x => x.type === 'function')
+            .groupBy(x => x.name)
+            .map(group => {
+                if (group.values.length === 1) {
+                    let item = group.values[0];
                     return Gen.serializeMethodTs(item);
                 }
+                if (group.values.length > 1) {
+                    let items = group.values;
+                    return Gen.serializeMethodTsOverloads(items);
+                }
                 return null;
             })
             .filter(Boolean)
-            .map(Str.formatMethod);
-            ;
+            .map(Str.formatMethod)
+            .toArray();
+
+        let methodInterfacesArr = alot(abiJson)
+            .filter(x => x.type === 'function')
+            .groupBy(x => x.name)
+            .map(group => {
+                let item = group.values[0];
+                return Gen.serializeMethodInterfacesTs(item.name, group.values);
+            })
+            .filter(Boolean)
+            .toArray();
+
+        let methodInterfacesAll = Gen.serializeMethodInterfacesAllTs(methodInterfacesArr);
 
         let eventsArr = abiJson
             .filter(x => x.type === 'event')
@@ -44,12 +71,21 @@ export class GeneratorFromAbi {
             .filter(Boolean)
             .map(Str.formatMethod);
             ;
+
+        let eventInterfacesAll = Gen.serializeEventsInterfacesAllTs(abiJson.filter(x => x.type === 'event'));
+
         let eventsExtractorsArr = abiJson
             .filter(x => x.type === 'event')
             .map(x => Gen.serializeEventExtractor(x))
             .filter(Boolean)
             .map(Str.formatMethod);
 
+        let eventsFetchersArr = abiJson
+            .filter(x => x.type === 'event')
+            .map(x => Gen.serializeEventFetcher(x))
+            .filter(Boolean)
+            .map(Str.formatMethod);
+
         let eventInterfaces = abiJson
             .filter(x => x.type === 'event')
             .map(x => Gen.serializeEventInterface(x))
@@ -60,15 +96,19 @@ export class GeneratorFromAbi {
         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 name = opts.name;
         let templatePath = $path.resolve(`/src/gen/ContractTemplate.ts`);
         let template = await File.readAsync<string>(templatePath, { skipHooks: true });
 
+
         let EtherscanStr;
         let EthWeb3ClientStr;
         let imports = [];
         let explorerUrl: string;
+        let Web3ClientOptions = '';
+        let EvmScanOptions = '';
         switch (opts.network) {
             case 'bsc':
                 EtherscanStr = 'Bscscan';
@@ -106,30 +146,86 @@ export class GeneratorFromAbi {
                 ];
                 explorerUrl = `https://etherscan.io/address/${opts.implementation}#code`;
                 break;
-            default:
-                throw new Error(`Unknown network ${opts.network}`);
+            case 'hardhat':
+                EtherscanStr = 'Etherscan';
+                EthWeb3ClientStr = 'HardhatWeb3Client';
+                imports = [
+                    `import { Etherscan } from '@dequanto/BlockchainExplorer/Etherscan'`,
+                    `import { HardhatWeb3Client } from '@dequanto/clients/HardhatWeb3Client'`,
+                ];
+                explorerUrl = ``;
+                break;
+            default: {
+                let web3Config = $config.get(`web3.${opts.network}`);
+                if (web3Config) {
+                    EtherscanStr = 'Evmscan';
+                    EthWeb3ClientStr = 'EvmWeb3Client';
+                    imports = [
+                        `import { Evmscan } from '@dequanto/BlockchainExplorer/Evmscan'`,
+                        `import { EvmWeb3Client } from '@dequanto/clients/EvmWeb3Client'`,
+                    ];
+                    Web3ClientOptions = `{ platform: '${opts.network}' }`;
+                    EvmScanOptions = `{ platform: '${opts.network}' }`;
+
+                    explorerUrl = '';
+                    let evmscan = $config.get(`blockchainExplorer.${opts.network}`)
+                    if (evmscan?.www) {
+                        explorerUrl = `${evmscan.www}/address/${opts.implementation}#code`;
+                    }
+                    break;
+                }
+
+                throw new Error(`Unknown network ${opts.network}, and no configuration found under "web3" field`);
+            }
+        }
+
+        let storageReaderProperty = '';
+        let storageReaderClass = '';
+        try {
+            let storageReaderGenerator = new GeneratorStorageReader();
+            let reader = await storageReaderGenerator.generate({ ...opts });
+            let property = reader.className
+                ? `storage = new ${reader.className}(this.address, this.client, this.explorer);`
+                : '';
+
+            storageReaderClass = reader.code;
+            storageReaderProperty = property;
+            $logger.log(`Storage Reader generated`);
+        } catch (error) {
+            $logger.log(`Storage Reader is skipped: ${error.message}`);
         }
 
         let code = template
             .replace(/\$Etherscan\$/g, EtherscanStr)
             .replace(/\$EthWeb3Client\$/g, EthWeb3ClientStr)
+            .replace(/\$Web3ClientOptions\$/g, Web3ClientOptions)
+            .replace(/\$EvmScanOptions\$/g, EvmScanOptions)
+
             .replace(`/* IMPORTS */`, imports.join('\n'))
-            .replace(`$NAME$`, Gen.toClassName(name))
+            .replace(`$NAME$`, $gen.toClassName(name))
             .replace(`$ADDRESS$`, opts.address ?? '')
             .replace(`/* METHODS */`, methods)
             .replace(`/* EVENTS */`, events)
             .replace(`/* EVENTS_EXTRACTORS */`, eventsExtractors)
+            .replace(`/* EVENTS_FETCHERS */`, eventsFetchers)
             .replace(`$ABI$`, JSON.stringify(abiJson))
             .replace(`$DATE$`, $date.format(new Date(), 'yyyy-MM-dd HH:mm'))
             .replace(`$EXPLORER_URL$`, explorerUrl)
-            .replace(`/* $EVENT_INTERFACES$ */`, eventInterfaces.join('\n'))
+            .replace(`/* $EVENT_INTERFACES$ */`, eventInterfaces.join('\n') + '\n\n' + eventInterfacesAll.code + '\n\n')
+
+            .replace(`/* STORAGE_READER_PROPERTY */`, storageReaderProperty)
+            .replace(`/* STORAGE_READER_CLASS */`, storageReaderClass || '')
+            .replace(`/* $METHOD_INTERFACES$ */`, methodInterfacesArr.map(x => x.code).join('\n\n') + '\n\n' + methodInterfacesAll.code + '\n\n')
             ;
 
 
         let directory = name;
         let filename = /[^\\/]+$/.exec(name)[0];
 
-        let path = class_Uri.combine(opts.output, directory, `${filename}.ts`);
+        let path = /\.ts$/.test(opts.output)
+            ? opts.output
+            : class_Uri.combine(opts.output, directory, `${filename}.ts`);
+
         await File.writeAsync(path, code, { skipHooks: true });
 
         if (opts.saveAbi) {
@@ -137,7 +233,7 @@ export class GeneratorFromAbi {
             await File.writeAsync(path, abiJson);
         }
 
-        console.log(`ABI wrapper class created: ${path}`);
+        $logger.log(`ABI wrapper class created: ${path}`);
 
         let sources = opts.sources;
         let sourceFiles = [];
@@ -147,7 +243,7 @@ export class GeneratorFromAbi {
                 let path = class_Uri.combine(opts.output, directory, filename, sourceFilename);
                 await File.writeAsync(path, entry.value.content, { skipHooks: true });
 
-                console.log(`Source code saved: ${path}`);
+                $logger.log(`Source code saved: ${path}`);
                 return path;
             }).toArrayAsync();
         }
@@ -161,14 +257,6 @@ export class GeneratorFromAbi {
 
 namespace Gen {
 
-    export function toClassName (name: string) {
-        let str = name.replace(/[^\w_\-\\/]/g, '');
-        str = str.replace(/[\-\\/](\w)/g, (full, letter) => {
-            return letter.toUpperCase();
-        });
-        return str[0].toUpperCase() + str.substring(1);
-    }
-
 
     export function serializeMethodTs (abi: AbiItem) {
         let isRead = isReader(abi);
@@ -177,20 +265,98 @@ namespace Gen {
         }
         return serializeWriteMethodTs(abi);
     }
+    export function serializeMethodTsOverloads (abis: AbiItem[]) {
+        let isRead = abis.every(abi => isReader(abi));
+        if (isRead) {
+            return serializeReadMethodTsOverloads(abis);
+        }
+        return serializeWriteMethodTsOverloads(abis);
+    }
+
+    // abi.length > 1 if has method overloads
+    export function serializeMethodInterfacesTs (name: string, abis: AbiItem[]) {
+        let args = abis.map(abi => {
+            let { fnInputArguments } = serializeArgumentsTs(abi);
+            return `[ ${fnInputArguments} ]`;
+        }).join(' | ');
+
+        let iface = `IMethod${name[0].toUpperCase()}${name.substring(1)}`;
+        let code = [
+            `interface ${iface} {`,
+            `  method: "${name}"`,
+            `  arguments: ${args}`,
+            `}`
+        ];
+        return {
+            method: name,
+            interface: iface,
+            code: code.join('\n')
+        };
+    }
+
+    export function serializeMethodInterfacesAllTs (methods: { method: string, interface: string }[] ) {
+        let fields = methods.map(method => {
+            return `  ${method.method}: ${method.interface}`;
+        });
+        let code = [
+            `interface IMethods {`,
+            ...fields,
+            `  '*': { method: string, arguments: any[] } `,
+            `}`
+        ];
+        return {
+            code: code.join('\n')
+        };
+    }
+    export function serializeEventsInterfacesAllTs (events: AbiItem[] ) {
+        let fields = events.map(item => {
+            return `  ${item.name}: TLog${item.name}Parameters`;
+        });
+        let code = [
+            `interface IEvents {`,
+            ...fields,
+            `  '*': any[] `,
+            `}`
+        ];
+        return {
+            code: code.join('\n')
+        };
+    }
 
     export function serializeEvent (abi: AbiItem) {
         let { fnInputArguments, callInputArguments, fnResult } = serializeArgumentsTs(abi);
         return `
-            on${abi.name} (fn: (event: EventData, ${fnInputArguments}) => void): ClientEventsStream<any> {
-                return this.$on('${abi.name}', fn);
+            on${abi.name} (fn?: (event: TClientEventsStreamData<TLog${abi.name}Parameters>) => void): ClientEventsStream<TClientEventsStreamData<TLog${abi.name}Parameters>> {
+                return this.$onLog('${abi.name}', fn);
             }
         `;
     }
     export function serializeEventExtractor (abi: AbiItem) {
         return `
-            extractLogs${abi.name} (tx: TransactionReceipt): TLog${abi.name}[] {
+            extractLogs${abi.name} (tx: TransactionReceipt): ITxLogItem<TLog${abi.name}>[] {
                 let abi = this.$getAbiItem('event', '${abi.name}');
-                return this.$extractLogs(tx, abi) as any as TLog${abi.name}[];
+                return this.$extractLogs(tx, abi) as any as ITxLogItem<TLog${abi.name}>[];
+            }
+        `;
+    }
+    export function serializeEventFetcher (abi: AbiItem) {
+        let inputs = abi.inputs;
+        let indexed = alot(inputs).takeWhile(x => x.indexed).toArray();
+        let indexedParams = indexed.map(param => `${param.name}?: ${ $abiType.getTsType(param.type, param) }`)
+        return `
+            async getPastLogs${abi.name} (options?: {
+                fromBlock?: number | Date
+                toBlock?: number | Date
+                params?: { ${indexedParams} }
+            }): Promise<ITxLogItem<TLog${abi.name}>[]> {
+                let topic = '${$abiUtils.getTopicSignature(abi)}';
+                let abi = this.$getAbiItem('event', '${abi.name}');
+                let filters = await this.$getPastLogsFilters(abi, {
+                    topic,
+                    ...options
+                });
+                let logs= await this.$getPastLogs(filters);
+                return logs.map(log => this.$extractLog(log, abi)) as any;
             }
         `;
     }
@@ -198,9 +364,9 @@ namespace Gen {
         let { fnInputArguments, callInputArguments, fnResult } = serializeArgumentsTs(abi);
         return `
             type TLog${abi.name} = {
-                contract: TAddress,
                 ${fnInputArguments}
-            }
+            };
+            type TLog${abi.name}Parameters = [ ${fnInputArguments.replace('\n', '')} ];
         `;
     }
 
@@ -236,6 +402,26 @@ namespace Gen {
             }
         `;
     }
+    function serializeReadMethodTsOverloads (abis: AbiItem[]) {
+        let overrides = abis.map(abi => {
+            let { fnInputArguments, fnResult } = serializeArgumentsTs(abi);
+            return `
+            // ${$abiUtils.getMethodSignature(abi)}
+            async ${abi.name} (${fnInputArguments}): ${fnResult}
+            `;
+        }).join('\n');
+
+        let abi = abis[0];
+        let { fnResult } = serializeArgumentsTs(abi);
+        let sigs = abis.map(abi => serializeMethodAbi(abi)).map(x => `'${x}'`).join(', ');
+        return `
+            ${ overrides }
+            async ${abi.name} (...args): ${fnResult} {
+                let abi = this.$getAbiItemOverload([ ${sigs} ], args);
+                return this.$read(abi, ...args);
+            }
+        `;
+    }
 
     function serializeWriteMethodTs (abi: AbiItem) {
         let { fnInputArguments, callInputArguments } = serializeArgumentsTs(abi);
@@ -245,8 +431,27 @@ namespace Gen {
 
         return `
             // ${$abiUtils.getMethodSignature(abi)}
-            async ${abi.name} (eoa: {address: TAddress, key: string, value?: string | number | bigint }, ${fnInputArguments}): Promise<TxWriter> {
-                return this.$write(this.$getAbiItem('function', '${abi.name}'), eoa${callInputArguments});
+            async ${abi.name} (sender: TSender, ${fnInputArguments}): Promise<TxWriter> {
+                return this.$write(this.$getAbiItem('function', '${abi.name}'), sender${callInputArguments});
+            }
+        `;
+    }
+    function serializeWriteMethodTsOverloads (abis: AbiItem[]) {
+        let overrides = abis.map(abi => {
+            let { fnInputArguments, fnResult } = serializeArgumentsTs(abi);
+            return `
+            // ${$abiUtils.getMethodSignature(abi)}
+            async ${abi.name} (sender: TSender, ${fnInputArguments}): Promise<TxWriter>
+            `;
+        }).join('\n');
+
+        let abi = abis[0];
+        let sigs = abis.map(abi => serializeMethodAbi(abi)).map(x => `'${x}'`).join(', ');
+        return `
+            ${ overrides }
+            async ${abi.name} (sender: TSender, ...args): Promise<TxWriter> {
+                let abi = this.$getAbiItemOverload([ ${sigs} ], args);
+                return this.$write(abi, sender, ...args);
             }
         `;
     }
@@ -257,6 +462,9 @@ namespace Gen {
             if (result.name == null || result.name === '') {
                 result.name = 'input' + i;
             }
+            if (result.name === 'sender') {
+                result.name = '_sender';
+            }
             return result;
         });
 
@@ -363,40 +571,4 @@ namespace Gen {
 }
 
 
-namespace Str {
-    export function formatMethod (str: string) {
-        str = trim(str);
-        str = indent(str, '    ');
-        return str;
-    }
-    export function trim (str: string) {
-        let lines = str.split('\n');
-        let min = alot(lines).min(x => {
-            if (x.trim() === '') {
-                return Number.MAX_SAFE_INTEGER;
-            }
-            let match = /^\s+/.exec(x);
-            if (match == null) {
-                return Number.MAX_SAFE_INTEGER;
-            }
-            return match[0].length;
-        });
 
-        lines = lines.map((line, i) => {
-            let x = line.substring(min);
-            if ((i === 0) || (lines.length === i + 1)) {
-                if (x === '') {
-                    return null;
-                }
-            }
-            return x;
-        }).filter(Boolean);
-        return lines.join('\n');
-    }
-    export function indent (str: string, indent: string) {
-        return str
-            .split('\n')
-            .map(x => `${indent}${x}`)
-            .join('\n');
-    }
-}

package/src/gen/GeneratorStorageReader.ts

@@ -0,0 +1,113 @@
+import alot from 'alot'
+import { Web3Client } from '@dequanto/clients/Web3Client'
+import { TAddress } from '@dequanto/models/TAddress'
+import { TPlatform } from '@dequanto/models/TPlatform'
+import { ISlotVarDefinition, SlotsParser } from '@dequanto/solidity/SlotsParser'
+import { $require } from '@dequanto/utils/$require'
+import { File } from 'atma-io'
+import { Str } from './utils/Str'
+import { $abiType } from '@dequanto/utils/$abiType'
+import { $path } from '@dequanto/utils/$path'
+import { $gen } from './utils/$gen'
+
+export class GeneratorStorageReader {
+
+    async generate(opts: {
+        network: TPlatform
+        name: string
+        contractName: string
+        address: TAddress
+        sources?: {
+            [file: string]: { content: string }
+        },
+        client?: Web3Client
+    }): Promise<{ code?: string, className?: string }> {
+
+
+        let { client, sources, contractName, address } = opts;
+        let files = alot.fromObject(sources ?? {}).map(x => {
+            return {
+                path: x.key,
+                content: x.value.content
+            };
+        }).toArray();
+
+        if (files.length === 0) {
+            return {};
+        }
+
+        let file = null as (typeof files[0]);
+        if (files.length === 1) {
+            file = files[0];
+        } else {
+            let rgx = new RegExp(`contract \s*${contractName}`, 'i')
+            let main = await alot(files.reverse()).findAsync(async x => {
+                return rgx.test(x.content);
+            });
+            if (main == null) {
+                main = files[0];
+            }
+            file = main;
+        }
+
+        $require.String(file?.content ?? file?.path, `Expected a source content to resolve slots`)
+
+        let slots = await SlotsParser.slots({ code: file.content, path: file.path }, contractName, { files })
+
+
+        let methods = this.serializeSlots(slots);
+        let codeMethods = methods.join('\n\n');
+
+        let templatePath = $path.resolve(`/src/gen/ContractStorageReaderTemplate.ts`);
+        let template = await File.readAsync<string>(templatePath, { skipHooks: true });
+        let className = $gen.toClassName(opts.name + 'StorageReader');
+        let code = template
+            .replace(`$NAME$`, className)
+            .replace(`/* METHODS */`, codeMethods)
+            .replace(`$SLOTS$`, JSON.stringify(slots, null, '    '))
+
+
+        return {
+            className: className,
+            code: code
+        };
+    }
+
+    private serializeSlots (slots: ISlotVarDefinition[]) {
+        return slots
+            .map(slot => this.serializeSlot(slot))
+            .map(Str.formatMethod);
+    }
+
+    private serializeSlot (slot: ISlotVarDefinition) {
+        let name = slot.name;
+        let type = slot.type;
+        let { parametersTypes, parametersCall, returnType } = this.getParameters(type);
+
+        return `
+            async ${name}(${parametersTypes ?? ''}): Promise<${returnType}> {
+                return this.$storage.get('${name}', ${ parametersCall ?? '' });
+            }
+        `;
+    }
+
+    private getParameters (type: string): { parametersTypes?, parametersCall?, returnType } {
+        if (type.startsWith('mapping')) {
+            let valueType = $abiType.mapping.getValueType(type);
+            let keyType = $abiType.mapping.getKeyType(type);
+
+            let keyTsType = $abiType.getTsTypeFromDefinition(keyType);
+            let valueTsType = $abiType.getTsTypeFromDefinition(valueType);
+            return {
+                parametersTypes: `key: ${keyTsType}`,
+                returnType: `${valueTsType}`,
+                parametersCall: 'key',
+            }
+        }
+
+        return {
+            returnType: $abiType.getTsTypeFromDefinition(type)
+        };
+    }
+}
+

package/src/gen/utils/$gen.ts

@@ -0,0 +1,11 @@
+
+export namespace $gen {
+
+    export function toClassName (name: string) {
+        let str = name.replace(/[^\w_\-\\/]/g, '');
+        str = str.replace(/[\-\\/](\w)/g, (full, letter) => {
+            return letter.toUpperCase();
+        });
+        return str[0].toUpperCase() + str.substring(1);
+    }
+}

package/src/gen/utils/Str.ts

@@ -0,0 +1,40 @@
+import alot from 'alot';
+
+export namespace Str {
+    export function formatMethod(str: string) {
+
+        str = trim(str);
+        str = indent(str, '    ');
+        return str;
+    }
+    export function trim(str: string) {
+        let lines = str.split('\n');
+        let min = alot(lines).min(line => {
+            if (line.trim() === '') {
+                return Number.MAX_SAFE_INTEGER;
+            }
+            let match = /^\s*/.exec(line);
+            if (match == null) {
+                return Number.MAX_SAFE_INTEGER;
+            }
+            return match[0].length;
+        });
+
+        lines = lines.map((line, i) => {
+            let x = line.substring(min);
+            if ((i === 0) || (lines.length === i + 1)) {
+                if (x === '') {
+                    return null;
+                }
+            }
+            return x;
+        }).filter(Boolean);
+        return lines.join('\n');
+    }
+    export function indent(str: string, indent: string) {
+        return str
+            .split('\n')
+            .map(x => `${indent}${x}`)
+            .join('\n');
+    }
+}

package/src/handlers/TokenHandler.ts

@@ -1,4 +1,4 @@
-import { ChainAccount } from '@dequanto/ChainAccounts';
+import { ChainAccount } from "@dequanto/models/TAccount";
 import { PlatformFactory } from '@dequanto/chains/PlatformFactory';
 import { IToken } from '@dequanto/models/IToken';
 import { TAddress } from '@dequanto/models/TAddress';