dequanto 0.2.49 → 0.2.51

package/src/clients/Web3ClientFactory.ts

@@ -7,6 +7,7 @@ import { EvmWeb3Client } from './EvmWeb3Client';
 import { $require } from '@dequanto/utils/$require';
 import { $config } from '@dequanto/utils/$config';
 import type { HardhatWeb3Client } from '@dequanto/hardhat/HardhatWeb3Client';
+import { IConfigData } from '@dequanto/config/interface/IConfigData';
 
 export namespace Web3ClientFactory {
 
@@ -14,9 +15,23 @@ export namespace Web3ClientFactory {
         TClient extends EvmWeb3Client | HardhatWeb3Client = EvmWeb3Client
     > (platform: TPlatform | number, opts?: IWeb3EndpointOptions): TClient {
         if (typeof platform === 'string' && (platform === 'hardhat' || platform.startsWith('hh:'))) {
-            let client = di.resolve(HardhatProvider).client('localhost', opts);
-            if (platform.startsWith('hh:')) {
-                client.configureFork(platform.slice(3));
+            // hardhat       - local hardhat network
+            // hh:eth        - local hardhat network (which runs as a fork)
+            // hh:memory     - in-memory hardhat network
+            // hh:memory:eth - getAsync only: in-memory forked hardhat network
+            if (platform.startsWith('hh:memory:')) {
+                throw new Error(`use getAsync to resolve forked "${platform}" client`);
+            }
+
+            let network = platform.startsWith('hh:')
+                ? platform.slice(3)
+                : null;
+            let hh = network === 'memory'
+                ? 'hardhat' as const
+                : 'localhost' as const;
+            let client = di.resolve(HardhatProvider).client(hh, opts);
+            if (network != null && network !== 'memory') {
+                client.configureFork(network);
             }
             return client as TClient;
         }
@@ -29,11 +44,24 @@ export namespace Web3ClientFactory {
         }) as TClient;
     }
 
+    type HHInMemoryForkData = {
+        block?: number
+        url?: string
+    }
     /** Same as the sync variant, but ensures the config is fetched */
     export async function getAsync <
         TClient extends EvmWeb3Client | HardhatWeb3Client = EvmWeb3Client
-    > (platform: TPlatform | string | number, opts?: IWeb3EndpointOptions): Promise<TClient> {
-        let cfg = await Config.get();
+    > (platform: TPlatform | string | number, opts?: IWeb3EndpointOptions & HHInMemoryForkData & { config?: Partial<IConfigData>}): Promise<TClient> {
+        let cfg = await Config.get(opts?.config);
+        if (typeof platform === 'string' && platform.startsWith('hh:memory:')) {
+            let network = platform.replace('hh:memory:', '');
+            let client = await di.resolve(HardhatProvider).forked({
+                platform: network,
+                block: opts?.block,
+                url: opts?.url,
+            });
+            return client as TClient;
+        }
         return get<TClient>(platform, opts);
     }
 }

package/src/clients/debug/ClientDebugMethods.ts

@@ -7,6 +7,7 @@ import { $hex } from '@dequanto/utils/$hex';
 import { TEth } from '@dequanto/models/TEth';
 import { $array } from '@dequanto/utils/$array';
 import { $date } from '@dequanto/utils/$date';
+import { $number } from '@dequanto/utils/$number';
 
 
 export class ClientDebugMethods {
@@ -53,10 +54,13 @@ export class ClientDebugMethods {
         return this.call('mine', ...args);
     }
 
-    setBalance (address: TAddress, amount: bigint | string) {
+    setBalance (address: TAddress, amount: bigint | number | string) {
         if (typeof amount === 'bigint') {
             amount = $bigint.toHex(amount);
         }
+        if (typeof amount === 'number') {
+            amount = $number.toHex(amount);
+        }
         return this.call('setBalance', address, amount);
     }
 

package/src/clients/utils/$web3Abi.ts

@@ -8,13 +8,13 @@ export namespace $web3Abi {
         let arr: TAbiItem[];
         if (typeof abi === 'string') {
             arr = [ $abiParser.parseMethod(abi) ];
-        } else  if (Array.isArray(abi)) {
+        } else if (Array.isArray(abi)) {
             arr = abi;
         } else {
             arr = [ abi ];
         }
 
-        let first = abi[0];
+        let first = arr[0];
         if (first.outputs == null || first.outputs.length === 0) {
             // Normalize outputs to read at least bytes if nothing is set
             first.outputs = [

package/src/config/AConfigBase.ts

@@ -5,6 +5,10 @@ import { TEth } from '@dequanto/models/TEth'
 
 type TConfigParamsBase = {
     config?: Partial<IConfigData>
+    // alias for config.web3.platform.endpoints
+    rpc?: {
+        [platform: string]: string | string[] | IConfigData['web3']['']['endpoints']
+    }
 }
 
 export type TConfigParamsNode = TConfigParamsBase & {

package/src/config/Config.ts

@@ -12,6 +12,27 @@ export class Config {
     static async fetch (parameters?: TConfigParamsNode | TConfigParamsBrowser): Promise<Appcfg<IConfigData> & IConfigData> {
         singleton ??= new class_Dfr();
 
+        if (parameters?.rpc) {
+            parameters.config ??= {};
+            parameters.config.web3 ??= {};
+            for (let platform in parameters.rpc) {
+                parameters.config.web3[platform] ??= {} as any;
+                parameters.config.web3[platform].endpoints = [];
+                let val = parameters.rpc[platform];
+                if (typeof val === 'string') {
+                    parameters.config.web3[platform].endpoints.push({
+                        url: val
+                    });
+                    continue;
+                }
+                if (Array.isArray(val) && typeof val[0] === 'string') {
+                    parameters.config.web3[platform].endpoints.push(...val.map(url => ({url})));
+                    continue;
+                }
+                parameters.config.web3[platform].endpoints = val as any;
+            }
+        }
+
         let cfg = await provider.fetch(parameters);
 
         obj_extend(config, cfg);
@@ -28,21 +49,22 @@ export class Config {
     }
 
     /** Will return a config that was previously loaded by fetch with any parameters or will trigger fetch with default parameters  */
-    static async get (): Promise<Appcfg<IConfigData> & IConfigData>  {
-        if (singleton != null) {
+    static async get (config?: Partial<IConfigData>): Promise<Appcfg<IConfigData> & IConfigData>  {
+        if (singleton != null && config == null) {
             return singleton;
         }
-        return Config.fetch();
+        return Config.fetch({ config });
     }
 
-    // static async getExplorerConfig (platform: TPlatform | number): Promise<TExplorer> {
-    //     let config = await Config.get();
-
-    // }
-
     static async extend (json) {
         await provider.extend(json);
     }
+
+    static clean (): Config {
+        memd.fn.clearMemoized(Config.fetch);
+        singleton = null;
+        return Config;
+    }
 }
 
 export const config = { } as IConfigData;

package/src/config/ConfigDefaults.ts

@@ -1,5 +1,6 @@
 import { IConfigData } from './interface/IConfigData';
-export const ConfigDefaults = <IConfigData> {
+import { DefaultFactory } from './DefaultFactory';
+export const ConfigDefaults = DefaultFactory({
     "accounts": null,
     "settings": {
         "generate": {
@@ -116,6 +117,9 @@ export const ConfigDefaults = <IConfigData> {
             "chainId": 1,
             "chainToken": "ETH",
             "endpoints": [
+                {
+                    "url": "https://ethereum-rpc.publicnode.com"
+                },
                 {
                     "url": "https://eth.drpc.org",
                     "rateLimit": "2000/5m"
@@ -504,4 +508,4 @@ export const ConfigDefaults = <IConfigData> {
         "base": "0x00000000000D6FFc74A8feb35aF5827bf57f6786",
         "linea": "0x00000000000D6FFc74A8feb35aF5827bf57f6786"
     }
-};
+});

package/src/config/ConfigProvider.ts

@@ -33,7 +33,6 @@ export class ConfigProvider implements IConfigProvider {
             ;
 
         let cfg = await AppConfig.fetch<IConfigData>(sources);
-
         if (this.config != null) {
             this.config.$extend(cfg.toJSON());
         } else {
@@ -102,6 +101,11 @@ export class ConfigProvider implements IConfigProvider {
             parameters?.dotenv ? {
                 dotenv: true
             } : null,
+            parameters?.config ? {
+                sync: true,
+                extendArrays: false,
+                config: parameters.config
+            } : null,
         ];
     }
 

package/src/config/DefaultFactory.ts

@@ -0,0 +1,26 @@
+import { IConfigData } from './interface/IConfigData';
+
+export function DefaultFactory (config: IConfigData): IConfigData {
+
+    if (typeof process !== 'undefined' && process.env != null) {
+        for (let key in process.env) {
+            if (key.startsWith('RPC_') === false) {
+                continue;
+            }
+            const platform = key.replace('RPC_', '').toLowerCase();
+            if (platform in config.web3 === false) {
+                continue;
+            }
+
+            const url = process.env[key];
+            if (/^(http|ws)/.test(url) === false) {
+                continue;
+            }
+            config.web3[platform].endpoints = [
+                { url: url }
+            ];
+        }
+    }
+
+    return config;
+}

package/src/config/interface/IConfigData.ts

@@ -4,6 +4,7 @@ import { TAddress } from '@dequanto/models/TAddress';
 import { TPlatform } from '@dequanto/models/TPlatform';
 import { IRpcConfig } from '@dequanto/clients/ClientPool';
 import { TChain } from '@dequanto/models/TChain';
+import { TEth } from '@dequanto/models/TEth';
 
 
 export interface IConfigData {
@@ -28,10 +29,10 @@ export interface IConfigData {
 
     blockchainExplorer: {
         [platform in TPlatform]: {
-            key: string;
+            key?: string;
             host?: string;
             api?: string
-            wwww?: string
+            www?: string
         };
     };
 
@@ -77,4 +78,16 @@ export interface IConfigData {
         [platform in TPlatform]: TAddress
     };
 
+    ns: {
+        [service: string]: {
+            [platform: string]: {
+                registry: TEth.Address
+                resolver?: TEth.Address
+            }
+        }
+    }
+
+    oracles: {
+        [service: string]: any
+    }
 }

package/src/contracts/ContractBase.ts

@@ -299,14 +299,18 @@ export abstract class ContractBase {
 
     protected $read(abi: string | TAbiItem, ...params) {
         if (this.builderConfig?.send === 'manual') {
+            let abiJson = typeof abi === 'string'
+                ? $abiParser.parseMethod(abi)
+                : abi;
             let req = <ContractReaderUtils.IContractReadParams>{
                 address: this.address,
-                abi,
+                abi: abiJson,
                 params: params,
                 blockNumber: this.blockNumber ?? this.blockDate,
                 options: {
                     from: this.builderConfig?.from
-                }
+                },
+                method: abiJson.name
             };
             return req;
         }

package/src/contracts/ContractReader.ts

@@ -302,9 +302,9 @@ export class ContractReader implements IContractReader {
         return filters as RpcTypes.Filter;
     }
 
-    static async read (client: Web3Client, address: TAddress, methodAbi: string){
+    static async read <TResult = any> (client: Web3Client, address: TAddress, methodAbi: string){
         let reader = new ContractReader(client);
-        return reader.readAsync(address, methodAbi);
+        return reader.readAsync<TResult>(address, methodAbi);
     }
 }
 
@@ -357,43 +357,6 @@ export namespace ContractReaderUtils {
     export async function readAsyncBatch(client: Web3Client, requests: (IContractReadParams | null)[], options?: {
         allowErrors?: boolean
     }) {
-
-        let rpcRequests = await alot(requests).map(async request => {
-            if (request == null) {
-                return null;
-            }
-            let abi = request.abi;
-            if (typeof abi === 'string') {
-                abi = $abiParser.parseMethod(abi);
-            }
-            let blockNumber = request.blockNumber;
-            if (blockNumber instanceof Date) {
-                let resolver = di.resolve(BlockDateResolver, client);
-                blockNumber = await resolver.getBlockNumberFor(blockNumber);
-            }
-            return {
-                address: request.address,
-                abi: [ abi ],
-                method: abi.name,
-                params: request.params,
-                blockNumber: blockNumber,
-                options: request.options
-            } as TRpcContractCall;
-        }).toArrayAsync();
-
-        let mapped = [];
-        let rpcRequestsNotEmpty = [];
-        for (let i = 0; i < rpcRequests.length; i++) {
-            if (rpcRequests[i] == null) {
-                continue;
-            }
-            let idx = rpcRequestsNotEmpty.push(rpcRequests[i]) - 1;
-            mapped[i] = idx;
-        }
-
-        let outputs = await client.readContractBatch(rpcRequestsNotEmpty, options);
-        return rpcRequests.map((_, i) => {
-            return outputs[mapped[i]] ?? null;
-        });
+        return await client.readContractBatch(requests, options);
     }
 }

package/src/explorer/BlockchainExplorer.ts

@@ -175,10 +175,10 @@ export class BlockchainExplorer implements IBlockchainExplorer {
         try {
             abi = await this.client.get(url);
         } catch (err) {
-            $logger.log(`Blockchain explorer request filed "${url}": ${err.message}`);
+            $logger.log(`Blockchain explorer request failed for "${url}": ${err.message}`);
             let addressByByteCode = await this.getSimilarContract(address);
             if (addressByByteCode != null) {
-                $logger.log(`Found similar byte code address: ${addressByByteCode}`);
+                $logger.log(`Found similar bytecode address: ${addressByByteCode}`);
                 return this.getContractAbi(addressByByteCode);
             }
             throw err;
@@ -195,7 +195,7 @@ export class BlockchainExplorer implements IBlockchainExplorer {
                 let hex = $address.fromBytes32(uin256Hex);
                 return this.getContractAbi(hex)
             }
-            throw new Error(`Implement ${params.implementation} support`);
+            throw new Error(`Implementation lookup is not supported for ${params.implementation}`);
         }
         if (isOpenZeppelinProxy(abiJson) || mightBeProxy(abiJson)) {
             let web3 = this.getWeb3(this.platform);
@@ -384,12 +384,12 @@ export class BlockchainExplorer implements IBlockchainExplorer {
             try {
                 return JSON.parse(str)
             } catch (error) {
-                // etherscan returns code wrapped into {{}}
+                // Etherscan can return source code wrapped in {{...}}
             }
             str = str
                 .replace(/^\s*\{\{/g, '{')
                 .replace(/\}\}\s*$/g, '}');
-            // @TODO check etherscan serialized jsons. Does it always has "{{...}}" wrappings
+            // @TODO Check Etherscan serialized JSON. Does it always use "{{...}}" wrapping?
 
             return JSON.parse(str)
         }
@@ -555,7 +555,7 @@ function hasMethod(abi: TAbiItem[], name: string) {
 function ensureDefaults(opts: TExplorerDefinition) {
 
     let platform = opts.platform;
-    $require.notNull(platform, `Generic Blockchain Explorer Config should contain platform name`);
+    $require.notNull(platform, `Generic blockchain explorer config must include a platform name`);
 
     opts.ABI_CACHE ??= `./cache/${$platform.toPath(platform)}/abis.json`
     opts.CONTRACTS ??= [];
@@ -594,7 +594,7 @@ class HttpClient {
     async getHtml(url: string) {
         let resp = await $http.get(url);
         if (resp.status !== 200) {
-            throw new Error(`${url} not loaded with status ${resp.status}.`);
+            throw new Error(`${url} failed to load with status ${resp.status}.`);
         }
         return resp.data;
     }
@@ -644,7 +644,7 @@ class HttpClient {
             throw error;
         }
         if (data.result == null) {
-            $logger.warn(`Blockchain "${url}" explorer returned empty result`, data);
+            $logger.warn(`Blockchain explorer "${url}" returned an empty result`, data);
         }
         return data.result as TOut;
     }
@@ -669,7 +669,7 @@ class HttpClient {
             throw new Error(str);
         }
         if (data.result == null) {
-            $logger.warn(`Blockchain "${url}" explorer returned empty result`, data);
+            $logger.warn(`Blockchain explorer "${url}" returned an empty result`, data);
         }
         return data.result;
     }

package/src/explorer/BlockchainExplorerFactory.ts

@@ -50,7 +50,7 @@ export namespace BlockchainExplorerFactory {
         return new BlockchainExplorer(params);
     }
 
-    /** Same as sync variation, but ensures the config is being fetched */
+    /** Same as the synchronous variant, but ensures the config has been fetched */
     export async function getAsync (platform: TPlatform, opts?: IBlockchainExplorerFactoryParams): Promise<IBlockchainExplorer> {
         await Config.get();
         return get(platform, opts);
@@ -58,7 +58,6 @@ export namespace BlockchainExplorerFactory {
 
     /** @obsolete Create instance directly with the get/getAsync method */
     export function create (opts: IBlockchainExplorerFactoryParams): Constructor<IBlockchainExplorer> {
-
         return class extends BlockchainExplorer {
             constructor (config?: IBlockchainExplorerFactoryParams) {
                 super(config ?? opts);

package/src/explorer/BlockchainExplorerProvider.ts

@@ -26,7 +26,7 @@ export namespace BlockchainExplorerProvider {
                 if (cfg != null) {
                     return new BlockchainExplorer({ platform, ...cfg });
                 }
-                throw new Error(`Unsupported platform ${platform} for block chain explorer`);
+                throw new Error(`Unsupported platform ${platform} for blockchain explorer`);
         }
     }
 

package/src/explorer/BlockchainExplorerStorage.ts

@@ -82,7 +82,7 @@ export class BlockchainExplorerStorage implements IBlockchainExplorer {
         let $address = opts?.implementation ?? address;
         let $contract = this.contracts[$address.toLowerCase()];
         $require.notNull($contract, `Contract "${$address}" not found`);
-        // @TODO: L1: return abi as json (means in *scan providers we must serialize it earlier)
+        // @TODO: L1: Return ABI as JSON. *scan providers should serialize it earlier.
         return {
             implementation: $address,
             abi: JSON.stringify($contract.abi)
@@ -92,7 +92,7 @@ export class BlockchainExplorerStorage implements IBlockchainExplorer {
         let _address = address;
         let _contract = this.contracts[_address.toLowerCase()];
         $require.notNull(_contract, `Contract "${_address}" not found`);
-        // @TODO: L1: return abi as json (means in *scan providers we must serialize it earlier)
+        // @TODO: L1: Return ABI as JSON. *scan providers should serialize it earlier.
         return {
             SourceCode: {
                 contractName: _contract.name,

package/src/explorer/ContractVerifier.ts

@@ -42,7 +42,7 @@ export class ContractVerifier {
     }
 
     async ensure (Ctor: TContractInfo, opts: TSubmissionOptions = {}): Promise<void>  {
-        this.logger.log(`Submit sources for ${typeof Ctor === 'string' ? Ctor : Ctor.name}`);
+        this.logger.log(`Submitting sources for ${typeof Ctor === 'string' ? Ctor : Ctor.name}`);
 
         let status = await this.submit(Ctor, opts);
         await this.waitForVerification(status, opts);
@@ -66,7 +66,7 @@ export class ContractVerifier {
             } catch (e) {
                 let message = e.message;
                 if (/verified/i.test(message)) {
-                    // was already verified
+                    // Already verified.
                     return true;
                 }
                 if (/(pending|queue)/i.test(message)) {
@@ -100,13 +100,13 @@ export class ContractVerifier {
         }
 
         try {
-            this.logger.log(`Checking if already verified ${address}`);
+            this.logger.log(`Checking whether contract ${address} is already verified`);
             let currentSources = await this.explorer.getContractSource(address);
             if ($is.notEmpty(currentSources?.ContractName)) {
                 return { status:'verified' };
             }
         } catch (error) {
-            // ignore any pre-check error and continue with the verification
+            // Ignore pre-check errors and continue with verification.
         }
 
         let deployedBytecode = await client.getCode(address);
@@ -140,7 +140,7 @@ export class ContractVerifier {
         }
 
         let jsonMetaPath = info.ctx.source.path;
-        $require.notEmpty(jsonMetaPath, `Deployment should return a path to compilation JSON`);
+        $require.notEmpty(jsonMetaPath, `Deployment should return a path to the compilation JSON`);
         $require.True(await File.existsAsync(jsonMetaPath) , `${jsonMetaPath} does not exist`);
 
         let jsonMeta = await File.readAsync<{ sourceName: string, contractName: string }>(jsonMetaPath);
@@ -150,7 +150,7 @@ export class ContractVerifier {
         let jsonMetaDbg = await File.readAsync<{ buildInfo: string }>(jsonMetaDbgPath);
 
         let jsonMetaBuildInfoPath = jsonMetaDbg.buildInfo;
-        $require.notEmpty(jsonMetaPath, `${jsonMetaDbgPath} should contain the path to the buildInfo json file`);
+        $require.notEmpty(jsonMetaPath, `${jsonMetaDbgPath} should contain the path to the build info JSON file`);
 
         let buildInfoPath = new class_Uri(new class_Uri(jsonMetaPath).toDir()).combine(jsonMetaBuildInfoPath).toString();
         $require.True(await File.existsAsync(buildInfoPath) , `${buildInfoPath} does not exist`);
@@ -170,7 +170,7 @@ export class ContractVerifier {
         }
         let buildInfo = await File.readAsync<TBuildInfo>(buildInfoPath);
 
-        $require.notNull(buildInfo.solcLongVersion, `${buildInfoPath} should contain the "solcLongVersion" information`);
+        $require.notNull(buildInfo.solcLongVersion, `${buildInfoPath} should contain the "solcLongVersion" value`);
 
         let sources = await this.getSources(jsonMeta.sourceName);
         let sourcesSerialized = JSON.stringify({
@@ -181,7 +181,7 @@ export class ContractVerifier {
 
         let sourcesSerializedWrapped = `${sourcesSerialized}`;
 
-        this.logger.log(`Submit ${jsonMeta.sourceName}:${jsonMeta.contractName} and dependencies to verify ${address} contract`);
+        this.logger.log(`Submitting ${jsonMeta.sourceName}:${jsonMeta.contractName} and dependencies to verify contract ${address}`);
 
         try {
             let guid = await this.explorer.submitContractVerification({
@@ -243,7 +243,7 @@ export class ContractVerifier {
 
         await crawlSourceFile(new SourceFile(main));
 
-        this.logger.log(`Found ${Object.keys(sources).length} source files: `, Object.keys(sources));
+        this.logger.log(`Found ${Object.keys(sources).length} source files:`, Object.keys(sources));
         return sources;
     }
 
@@ -284,7 +284,7 @@ export class ContractVerifier {
             } catch (e) {
                 let message = e.message;
                 if (/verified|success/i.test(message)) {
-                    // was already verified
+                    // Already verified.
                     return true;
                 }
                 if (/(pending|queue)/i.test(message)) {

package/src/explorer/IBlockchainExplorer.ts

@@ -3,9 +3,13 @@ import { IAbiProvider } from './IAbiProvider';
 import { TEth } from '@dequanto/models/TEth';
 import { TAddress } from '@dequanto/models/TAddress';
 import { IVerifier } from './verifiers/IVerifier';
+import { TExplorerDefinition } from '@dequanto/models/TExplorer';
 
 
 export interface IBlockchainExplorer extends IAbiProvider, IVerifier {
+    config?: {
+        api?: { url?: string; key?: string }
+    }
     inMemoryDb: IContractDetails[]
     getContractMeta(q: string): Promise<IContractDetails>;
     getContractCreation(address: TEth.Address): Promise<{ creator: TEth.Address, txHash: TEth.Hex }>;

package/src/explorer/verifiers/FsHtmlVerifier.ts

@@ -115,7 +115,7 @@ export class FsHtmlVerifier implements IVerifier {
 
 
         if (contractData.contractName.includes('Utils/Proxy')) {
-            // fix Proxy, rename contract duplicates
+            // Rename duplicate Proxy contracts before writing the verification form.
             html = html.replaceAll('contracts/Utils/Proxy.sol:Proxy', 'contracts/Utils/TUProxy.sol:TUProxy');
             html = html.replace('Utils/Proxy.sol":', 'Utils/TUProxy.sol":');
             html = html.replace('contract Proxy is ', 'contract TUProxy is ');

package/src/models/TPlatform.ts

@@ -14,5 +14,6 @@ export type TPlatform = 'eth'
     | 'hardhat'
     | 'optimism'
     | 'avalanche'
+    | 'hh:memory'
     | `hh:${string}`
     | string;