dequanto 0.1.21 → 0.1.22

package/src/hardhat/HardhatProvider.ts

@@ -4,11 +4,11 @@ import { class_Uri } from 'atma-utils';
 import { File, env, Directory } from 'atma-io';
 
 import type { ContractBase } from '@dequanto/contracts/ContractBase';
-import type { Constructor } from 'atma-utils/mixin';
+
 import type { TAbiItem } from '@dequanto/types/TAbi';
 import type { TEth } from '@dequanto/models/TEth';
 
-import { EoAccount } from "@dequanto/models/TAccount";
+import { EoAccount } from '@dequanto/models/TAccount';
 import { HardhatWeb3Client } from '@dequanto/hardhat/HardhatWeb3Client';
 import { Web3Client } from '@dequanto/clients/Web3Client';
 
@@ -34,6 +34,7 @@ import { TAddress } from '@dequanto/models/TAddress';
 import { $contract } from '@dequanto/utils/$contract';
 import { $dependency } from '@dequanto/utils/$dependency';
 import { TTransport } from '@dequanto/rpc/transports/ITransport';
+import { Constructor } from '@dequanto/utils/types';
 
 type THardhatLib = typeof import('hardhat');
 
@@ -263,12 +264,14 @@ export class HardhatProvider {
         };
     }
 
-    async compileSol<T extends ContractBase = IContractWrapped> (solContractPath: string, options?: {
+    async compileSolDirectory (dir: string, options?: {
         paths?: {
             root?: string
             artifacts?: string
         },
         contractName?: string
+        tsgen?: boolean
+        install?: string
     }): Promise<{
         abi: TAbiItem[]
         bytecode: TEth.Hex
@@ -276,123 +279,79 @@ export class HardhatProvider {
         // renamed output
         artifact: string
         source: IGeneratorSources
-        ContractCtor: Constructor<T>
+        ContractCtor: Constructor<IContractWrapped>
         linkReferences?: Record<string /* path */, Record<string /* name */, any>>
-    }> {
-
-        solContractPath = $path.normalize(solContractPath);
-
-        const dir = solContractPath.replace(/[^\/]+$/, '');
-        const filename = /(?<filename>[^\/]+)\.\w+$/.exec(solContractPath)?.groups.filename;
-        // Filename could contain have random number, extract main-name
-        const filenameRndSuffix = filename.replace(/_\d+$/, '');
-
-        let root = options?.paths?.root;
-        let artifacts = options?.paths?.artifacts;
+    }[]> {
 
-        if (filename == null) {
-            throw new Error(`Filename not extracted from ${solContractPath}`);
+        dir = $path.normalize(dir);
+        if (await Directory.existsAsync(dir) === false) {
+            throw new Error(`Directory "${dir}" does not exist.`);
         }
-
-        let hhOptions = {
+        const paths = {
             sources: dir,
-            root,
-            artifacts,
-            tsgen: false,
+            root: options?.paths?.root,
+            artifacts: options?.paths?.artifacts,
+        };
+        const hhOptions = {
+            ...paths,
+            tsgen: options?.tsgen ?? false,
+            install: options?.install ?? null
         };
         const hh = await this.getHardhat();
         await hh.run('compile', hhOptions);
 
-        if (root == null) {
-            root = 'file://' + $path.normalize(process.cwd());
-        }
-        if (artifacts == null && root != null) {
-            artifacts = class_Uri.combine(root, 'artifacts/');
-        }
-
-        if (solContractPath.toLowerCase().includes(root.toLowerCase())) {
-            let i = solContractPath.toLowerCase().indexOf(root.toLowerCase());
-            solContractPath = solContractPath.substring(i + root.length);
-        }
+        const files = await Directory.readFilesAsync(paths.sources, '*.sol');
 
-        let outputDir = class_Uri.combine(artifacts, solContractPath);
-        let output = class_Uri.combine(outputDir, `${filename}.json`);
-        if (await File.existsAsync(output) === false) {
-            let path = `${outputDir}/`;
-            if (await Directory.existsAsync(path) === false) {
-                throw new Error(`No JSONs found in ${outputDir}, nor ${output}`);
-            }
-            let files = await Directory.readFilesAsync(path);
-            let jsons = files.filter(x => /(?<!dbg)\.json$/.test(x.uri.file));
-            if (jsons.length === 0) {
-                throw new Error(`No JSONs output found in "${outputDir}/"`);
-            }
-            if (jsons.length === 1) {
-                output = jsons[0].uri.toString();
-            } else {
-                let jsonFile = getJsonFile(jsons, filename);
-                if (jsonFile == null) {
-                    jsonFile = getJsonFile(jsons, filenameRndSuffix);
-                }
-                if (jsonFile == null) {
-                    let contractName = options?.contractName;
-                    if (contractName == null) {
-                        let source = await File.readAsync<string>(solContractPath);
-                        let rgx = /contract \s*(?<contractName>[\w_]+)/ig;
-                        let matches = Array.from(source.matchAll(rgx));
-                        contractName = matches[matches.length - 1]?.groups?.contractName;
-                        options.contractName = contractName;
-                    }
-                    jsonFile = getJsonFile(jsons, contractName);
-                }
-
-                if (jsonFile == null) {
-                    $logger.log(`Files: ${ files.map(file => file.uri.file ).join(', ')}`);
-                    throw new Error(`Compiled JSON data not found for "${filename}" in "${outputDir}/"`);
-                }
-                output = jsonFile.uri.toString();
-            }
-        }
-        function getJsonFile (files: InstanceType<typeof File>[], filename: string) {
-            return files.find(file => {
-                return file.uri.file === `${filename}.json`;
+        return await alot(files).mapAsync(async file => {
+            let solContractPath = file.uri.toLocalFile();
+            return await this.getContractFromSolPath(solContractPath, {
+                paths
             });
-        }
+        }).toArrayAsync();
+    }
 
-        let { abi, bytecode, contractName, linkReferences } = await File.readAsync<{
-            abi,
-            bytecode,
-            contractName,
-            linkReferences: Record<string /* path */, Record<string /* name */, any>>
-        }> (output);
-        let files = await Directory.readFilesAsync(dir, '*.sol');
-        let { contract, ContractCtor } = ContractClassFactory.fromAbi<T>(null, abi, null, null, {
-            $meta: {
-                artifact: output
-            }
-        })
+    async compileSol<T extends ContractBase = IContractWrapped> (solContractPath: string, options?: {
+        paths?: {
+            root?: string
+            artifacts?: string
+        },
+        contractName?: string
+        tsgen?: boolean
+        install?: string
+    }): Promise<{
+        abi: TAbiItem[]
+        bytecode: TEth.Hex
+        output: string
+        // renamed output
+        artifact: string
+        source: IGeneratorSources
+        ContractCtor: Constructor<T>
+        linkReferences?: Record<string /* path */, Record<string /* name */, any>>
+    }> {
 
-        let fileMap = await alot(files)
-        .mapAsync(async file => {
-            return {
-                key: file.uri.toString(),
-                content: await file.readAsync<string>()
-            };
-        })
-        .toDictionaryAsync(x => x.key, x => ({ content: x.content }));
+        solContractPath = $path.normalize(solContractPath);
 
-        return {
-            abi,
-            bytecode,
-            output,
-            artifact: output,
-            source: {
-                contractName: contractName ?? options?.contractName,
-                files: fileMap
-            },
-            linkReferences,
-            ContractCtor
+        const dir = $path.getDirectory(solContractPath);
+        const paths = {
+            sources: dir,
+            root: options?.paths?.root,
+            artifacts: options?.paths?.artifacts,
         };
+
+        let hhOptions = {
+            ...paths,
+
+            tsgen: options?.tsgen ?? false,
+            install: options?.install ?? null
+        };
+        const hh = await this.getHardhat();
+        await hh.run('compile', hhOptions);
+
+
+        return await this.getContractFromSolPath<T> (solContractPath, {
+            contractName: options?.contractName,
+            paths
+        });
     }
 
     async deployCode <TReturn extends ContractBase = IContractWrapped> (
@@ -507,4 +466,167 @@ export class HardhatProvider {
         return hh.network.provider as any as TTransport.Transport;
     }
 
+
+    private async getArtifactJsonPath (solContractPath: string, options: {
+        contractName?: string
+        paths: {
+            root: string
+            artifacts: string
+        }
+    }) {
+        let outputDir = class_Uri.combine(options.paths.artifacts, solContractPath, '/');
+        if (await Directory.existsAsync(outputDir) === false) {
+            throw new Error(`No JSONs found in ${outputDir} for ${solContractPath}`);
+        }
+
+        if (options.contractName != null) {
+            let artifactJsonPath = class_Uri.combine(outputDir, `${options.contractName}.json`);
+            if (await File.existsAsync(artifactJsonPath)) {
+                return artifactJsonPath;
+            }
+        }
+        const { filename } = $path.getFilename(solContractPath);
+
+        if (filename != null) {
+            let artifactJsonPath = class_Uri.combine(outputDir, `${filename}.json`);
+            if (await File.existsAsync(artifactJsonPath)) {
+                return artifactJsonPath;
+            }
+        }
+        if (filename == null) {
+            throw new Error(`Filename not extracted from ${solContractPath}`);
+        }
+
+
+        // Filename could contain random number, extract main-name
+
+
+        let files = await Directory.readFilesAsync(outputDir);
+        let jsons = files.filter(x => /(?<!dbg)\.json$/.test(x.uri.file));
+        if (jsons.length === 0) {
+            throw new Error(`No JSONs output found in "${outputDir}/"`);
+        }
+        if (jsons.length === 1) {
+            // Only one JSON artifact found, assume it's the main contract
+            let artifactJsonPath = jsons[0].uri.toString();
+            return artifactJsonPath;
+        }
+
+
+        let jsonFile = getJsonFile(jsons, filename);
+        if (jsonFile == null) {
+            const filenameRndSuffix = filename.replace(/_\d+$/, '');
+            if (filenameRndSuffix != null) {
+                jsonFile = getJsonFile(jsons, filenameRndSuffix);
+            }
+        }
+        if (jsonFile == null) {
+            let sourceFile = solContractPath;
+            if (await File.existsAsync(sourceFile) === false) {
+                sourceFile = class_Uri.combine(options.paths.root, sourceFile);
+            }
+            if (await File.existsAsync(sourceFile) === false) {
+                throw new Error(`Source file "${solContractPath}" not found in ${options.paths.root}`);
+            }
+
+
+            let source = await File.readAsync<string>(sourceFile);
+            let rgx = /contract \s*(?<contractName>[\w_]+)/ig;
+            let matches = Array.from(source.matchAll(rgx));
+            let contractName = matches[matches.length - 1]?.groups?.contractName;
+            options.contractName = contractName;
+            jsonFile = getJsonFile(jsons, contractName);
+        }
+
+        if (jsonFile == null) {
+            $logger.log(`Files: ${ files.map(file => file.uri.file ).join(', ')}`);
+            throw new Error(`Compiled JSON data not found for "${filename}" in "${outputDir}/"`);
+        }
+        let artifactJsonPath = jsonFile.uri.toString();
+        return artifactJsonPath;
+
+
+        function getJsonFile (files: InstanceType<typeof File>[], filename: string) {
+            return files.find(file => {
+                return file.uri.file === `${filename}.json`;
+            });
+        }
+    }
+
+    private async getPaths (paths?: { root?: string, artifacts?: string }) {
+        let root = paths?.root;
+        let artifacts = paths?.artifacts;
+
+        if (root == null) {
+            root = 'file://' + $path.normalize(process.cwd());
+        }
+        if (artifacts == null) {
+            artifacts = class_Uri.combine(root, 'artifacts/');
+        }
+
+        return { root, artifacts };
+    }
+
+
+    private async getContractFromSolPath <T extends ContractBase = IContractWrapped>  (solContractPath, options: {
+        contractName?: string
+        paths: {
+            sources: string
+            root?: string;
+            artifacts?: string;
+        };
+    }) {
+
+        let { root, artifacts } = await this.getPaths (options?.paths);
+        let solContractPathRootRelative = $path.getRelativePath(solContractPath, root);
+
+        let artifactJsonPath = await this.getArtifactJsonPath(solContractPathRootRelative, {
+            contractName: options?.contractName,
+            paths: {
+                root,
+                artifacts,
+            },
+        })
+
+        let { abi, bytecode, contractName, linkReferences } = await File.readAsync<IJsonArtifact> (artifactJsonPath);
+        let { contract, ContractCtor } = ContractClassFactory.fromAbi<T>(null, abi, null, null, {
+            contractName,
+            $meta: {
+                name: contractName,
+                source: solContractPathRootRelative,
+                artifact: artifactJsonPath
+            }
+        })
+
+        let files = await Directory.readFilesAsync(options.paths.sources, '*.sol');
+        let fileMap = await alot(files)
+            .mapAsync(async file => {
+                return {
+                    key: file.uri.toString(),
+                    content: await file.readAsync<string>()
+                };
+            })
+            .toDictionaryAsync(x => x.key, x => ({ content: x.content }));
+
+        return {
+            abi,
+            bytecode,
+            output: artifactJsonPath,
+            artifact: artifactJsonPath,
+            source: {
+                contractName: contractName ?? options?.contractName,
+                files: fileMap
+            },
+            linkReferences,
+            ContractCtor
+        };
+    }
+}
+
+
+interface IJsonArtifact {
+    abi: TEth.Abi.Item[]
+    bytecode: TEth.Hex
+    contractName: string
+    linkReferences: Record<string /* path */, Record<string /* name */, any>>
 }

package/src/json/JsonArrayMultiStore.ts

@@ -89,14 +89,16 @@ export class JsonArrayMultiStore<T> {
     private async getGroupedFiles () {
         try {
             let files = await Directory.readFilesAsync(this.options.path, '*.json');
-            let rangeFiles = files
+            let rangeFiles = alot(files)
             .map(file => {
                 return {
                     file,
                     range: this.parseRangeFilename(file.uri.file)
                 };
             })
-            .filter(x => x.range != null);
+            .filter(x => x.range != null)
+            .sortBy(x => x.range.start, 'asc')
+            .toArray();
             return rangeFiles;
         } catch (e) {
             return [];

package/src/json/JsonArrayStore.ts

@@ -2,7 +2,7 @@ import alot from 'alot'
 import { JsonConvert } from 'class-json'
 import { Alot } from 'alot/alot'
 import { JsonStoreFs } from './JsonStoreFs'
-import type { Constructor } from 'atma-utils'
+import { Constructor } from '@dequanto/utils/types'
 
 export interface IStoreOptions<T, TStorage = T> {
     path: string

package/src/models/TEth.ts

@@ -201,7 +201,7 @@ export namespace TEth {
         }
 
         export interface Input {
-            name: string;
+            name?: string;
             type: string;
             indexed?: boolean;
             components?: Input[];
@@ -209,7 +209,7 @@ export namespace TEth {
         }
 
         export interface Output {
-            name: string;
+            name?: string;
             type: string;
             components?: Output[];
             internalType?: string;

package/src/solidity/SlotsStorage.ts

@@ -7,7 +7,8 @@ import { SlotDynamicArrayHandler } from './storage/handlers/SlotDynamicArrayHand
 import { SlotsStorageTransport, ISlotsStorageTransport, SlotsCursorTransport } from './storage/SlotsStorageTransport';
 import { TAddress } from '@dequanto/models/TAddress';
 import { ASlotsStorageHandler } from './storage/SlotsStorageHandler';
-import { Constructor, is_Object } from 'atma-utils';
+import { Constructor } from '@dequanto/utils/types';
+import { is_Object } from 'atma-utils';
 import { SlotMappingHandler } from './storage/handlers/SlotMappingHandler';
 import { SlotStringHandler } from './storage/handlers/SlotStringHandler';
 import { Accessor, IAccessorItem } from './storage/Accessor';

package/src/types/TAbi.ts

@@ -20,13 +20,13 @@ export interface TAbiInput {
     name?: string;
     type: string;
     indexed?: boolean;
-	components?: TAbiInput[];
+    components?: TAbiInput[];
     internalType?: string;
 }
 
 export interface TAbiOutput {
     name?: string;
     type: string;
-	components?: TAbiOutput[];
+    components?: TAbiOutput[];
     internalType?: string;
 }

package/src/utils/$abiParser.ts

@@ -124,10 +124,17 @@ export namespace $abiParser {
             }
             let tupleName = line.substring(end + 1, delimiter).trim();
             if (tupleName) {
+                let type = 'tuple';
+                // e.g. tupleName "[] users" from (uint256 foo, uint256 bar)[] users
+                let arrMatch = /\[(\d+)?\]/.exec(tupleName);
+                if (arrMatch != null) {
+                    type = type + arrMatch[0];
+                    tupleName = tupleName.substring(arrMatch[0].length).trim();
+                }
                 return [
                     {
                         name: tupleName,
-                        type: `tuple`,
+                        type,
                         components: params
                     }
                 ];

package/src/utils/$bigint.ts

@@ -1,6 +1,7 @@
 import { TEth } from '@dequanto/models/TEth';
 import { $buffer } from './$buffer';
 import { $require } from './$require';
+import { $is } from '@dequanto/utils/$is';
 
 export namespace $bigint {
 
@@ -48,6 +49,46 @@ export namespace $bigint {
         return BigInt(Math.round(amount));
     }
 
+    /**
+     * @param amount e.g "2.4 ether", "10 gwei", "1.7^18", "123456"
+     */
+    export function parse (amount: string): bigint {
+        if (/^\d+$/.test(amount) || $is.Hex(amount) ) {
+            return BigInt(amount);
+        }
+        let rgxName = /^(?<number>[\d.]+)\s*(?<name>ether|gwei|wei)$/i;
+        let rgxMatch = rgxName.exec(amount);
+        if (rgxMatch != null) {
+            let number = Number(rgxMatch.groups.number);
+            if (isNaN(number)) {
+                throw new Error(`Invalid format: ${amount}`);
+            }
+            let name = rgxMatch.groups.name;
+            if (name === 'ether') {
+                return toWei(number, ETHER_DECIMALS);
+            }
+            if (name === 'gwei') {
+                return toWei(number, GWEI_DECIMALS);
+            }
+            if (name === 'wei') {
+                return BigInt(number);
+            }
+        }
+
+        // 2.5^18
+        let rgxMantissa = /^(?<number>[\d.]+)\s*\^\s*(?<decimals>\d+)$/;
+        let rgxMantissaMatch = rgxMantissa.exec(amount);
+        if (rgxMantissaMatch != null) {
+            let number = Number(rgxMantissaMatch.groups.number);
+            let decimals = Number(rgxMantissaMatch.groups.decimals);
+            if (isNaN(number) || isNaN(decimals)) {
+                throw new Error(`Invalid format: ${amount}`);
+            }
+            return toWei(number, decimals);
+        }
+        throw new Error(`Unsupported format: ${amount}`);
+    }
+
     export function ensureWei (amount: number | bigint, decimals: number) {
         if (typeof amount === 'number') {
             return toWei(amount, decimals);

package/src/utils/$contract.ts

@@ -124,12 +124,17 @@ export namespace $contract {
         let evm = new EvmBytecode(input, { withConstructorCode: true });
         let opcodes = evm.getOpcodes();
         let codeSize = opcodes.findIndex(x => x.name === 'CODESIZE');
+        if (codeSize === -1) {
+            return {
+                bytecode: input,
+                arguments: '0x',
+            };
+        }
         let prev = opcodes[codeSize - 1];
         $require.True(/PUSH/.test(prev.name), `PUSH expected but got ${prev.name}`);
 
         let codeSizeValue = $buffer.toBigInt(prev.pushData) * 2n;
         let inputCursor = 2 /*0x*/ + Number(codeSizeValue);
-
         return {
             bytecode: input.substring(0, inputCursor),
             arguments: '0x' + input.substring(inputCursor),

package/src/utils/$path.ts

@@ -45,6 +45,24 @@ export namespace $path {
         }
         return path;
     }
+    export function getDirectory (path: string) {
+        const dir = path.replace(/[^\/\\]+$/, '');
+        return dir;
+    }
+
+    export function getFilename (path: string) {
+        const match = /(?<filename>[^\/\\]+)\.(?<extension>\w+)$/.exec(path);
+        const { filename, extension } = match?.groups ?? { filename: null, extension: null };
+        return { filename, extension };
+    }
+
+    export function getRelativePath (path: string, base: string) {
+        let i = path.toLowerCase().indexOf(base.toLowerCase());
+        if (i > -1) {
+            return path.substring(i + base.length);
+        }
+        return path;
+    }
 
     function getRoot () {
         let base = $config.get('settings.base');

package/src/utils/$sig.ts

@@ -681,7 +681,7 @@ export namespace $sig {
 
 type TKey = TEth.Hex | `p1:0x${string}`;
 
-namespace KeyUtils {
+export namespace KeyUtils {
     const rgx = /^p1:/
 
     export async function withKey <TReturn> (account: TEth.EoAccount, fn: (account: TEth.EoAccount) => TReturn): Promise<TReturn> {

package/src/utils/types.ts

@@ -17,6 +17,9 @@ export type DeepPartial<T> = {
         DeepPartial<T[P]> | T[P]
 };
 
+export type Constructor<T = {}> = {
+    new (...args: any[]): T;
+};
 
 
 export type IntersectionTypeWithArrays<T1, T2, arrayKeys extends (keyof T1 & keyof T2)> = (