dequanto 0.2.49 → 0.2.50

package/lib/types/clients/debug/ClientDebugMethods.d.ts

@@ -15,7 +15,7 @@ export declare class ClientDebugMethods {
      * @param intervalSeconds Default: 1 block in 1 second
      */
     mine(blocks?: number | bigint | string, intervalSeconds?: number | bigint): Promise<any>;
-    setBalance(address: TAddress, amount: bigint | string): Promise<any>;
+    setBalance(address: TAddress, amount: bigint | number | string): Promise<any>;
     reset(params?: {
         forking?: {
             jsonRpcUrl?: any;

package/lib/types/config/AConfigBase.d.ts

@@ -1,6 +1,9 @@
 import { IConfigData } from './interface/IConfigData';
 type TConfigParamsBase = {
     config?: Partial<IConfigData>;
+    rpc?: {
+        [platform: string]: string | string[] | IConfigData['web3']['']['endpoints'];
+    };
 };
 export type TConfigParamsNode = TConfigParamsBase & {
     dotenv?: boolean;

package/lib/types/config/Config.d.ts

@@ -4,7 +4,8 @@ import { IConfigData } from './interface/IConfigData';
 export declare class Config {
     static fetch(parameters?: TConfigParamsNode | TConfigParamsBrowser): Promise<Appcfg<IConfigData> & IConfigData>;
     /** Will return a config that was previously loaded by fetch with any parameters or will trigger fetch with default parameters  */
-    static get(): Promise<Appcfg<IConfigData> & IConfigData>;
+    static get(config?: Partial<IConfigData>): Promise<Appcfg<IConfigData> & IConfigData>;
     static extend(json: any): Promise<void>;
+    static clean(): Config;
 }
 export declare const config: IConfigData;

package/lib/types/config/DefaultFactory.d.ts

@@ -0,0 +1,2 @@
+import { IConfigData } from './interface/IConfigData';
+export declare function DefaultFactory(config: IConfigData): IConfigData;

package/lib/types/config/interface/IConfigData.d.ts

@@ -4,6 +4,7 @@ import { TAddress } from '../../models/TAddress';
 import { TPlatform } from '../../models/TPlatform';
 import { IRpcConfig } from '../../clients/ClientPool';
 import { TChain } from '../../models/TChain';
+import { TEth } from '../../models/TEth';
 export interface IConfigData {
     settings: {
         /** Root path of the dequanto library */
@@ -24,10 +25,10 @@ export interface IConfigData {
     tokens: ITokenGlob[];
     blockchainExplorer: {
         [platform in TPlatform]: {
-            key: string;
+            key?: string;
             host?: string;
             api?: string;
-            wwww?: string;
+            www?: string;
         };
     };
     chains: TChain[];
@@ -69,4 +70,15 @@ export interface IConfigData {
     spotPriceAggregator?: {
         [platform in TPlatform]: TAddress;
     };
+    ns: {
+        [service: string]: {
+            [platform: string]: {
+                registry: TEth.Address;
+                resolver?: TEth.Address;
+            };
+        };
+    };
+    oracles: {
+        [service: string]: any;
+    };
 }

package/lib/types/contracts/ContractReader.d.ts

@@ -48,7 +48,7 @@ export declare class ContractReader implements IContractReader {
             [key: string]: any;
         } | any[];
     }): Promise<RpcTypes.Filter>;
-    static read(client: Web3Client, address: TAddress, methodAbi: string): Promise<any>;
+    static read<TResult = any>(client: Web3Client, address: TAddress, methodAbi: string): Promise<TResult>;
 }
 export declare namespace ContractReaderUtils {
     class DeferredRequest<T = any> {

package/lib/types/explorer/IBlockchainExplorer.d.ts

@@ -4,6 +4,12 @@ import { TEth } from '../models/TEth';
 import { TAddress } from '../models/TAddress';
 import { IVerifier } from './verifiers/IVerifier';
 export interface IBlockchainExplorer extends IAbiProvider, IVerifier {
+    config?: {
+        api?: {
+            url?: string;
+            key?: string;
+        };
+    };
     inMemoryDb: IContractDetails[];
     getContractMeta(q: string): Promise<IContractDetails>;
     getContractCreation(address: TEth.Address): Promise<{

package/lib/types/models/TPlatform.d.ts

@@ -1 +1 @@
-export type TPlatform = 'eth' | 'eth:goerli' | 'bsc' | 'polygon' | 'arbitrum' | 'xdai' | 'boba' | 'hardhat' | 'optimism' | 'avalanche' | `hh:${string}` | string;
+export type TPlatform = 'eth' | 'eth:goerli' | 'bsc' | 'polygon' | 'arbitrum' | 'xdai' | 'boba' | 'hardhat' | 'optimism' | 'avalanche' | 'hh:memory' | `hh:${string}` | string;

package/lib/types/utils/$account.d.ts

@@ -4,4 +4,5 @@ export declare namespace $account {
     function isSafe(account: TAccount): account is SafeAccount;
     function isErc4337(account: TAccount): account is Erc4337Account;
     function isTimelock(account: TAccount): account is TimelockAccount;
+    function generate(name: string): EoAccount;
 }

package/lib/types/utils/$erc20.d.ts

@@ -0,0 +1,5 @@
+import { TEth } from '../models/TEth';
+import { Web3Client } from '../clients/Web3Client';
+export declare namespace $erc20 {
+    function setBalanceAny(client: Web3Client, token: TEth.Address, account: TEth.Address, amount: bigint | number): Promise<void>;
+}

package/lib/types/utils/$require.d.ts

@@ -17,8 +17,8 @@ export declare namespace $require {
     function Function<T>(val: T, message: string): NonNullable<T>;
     function Array<T>(val: T, message: string): NonNullable<T>;
     function String<T>(val: T, message: string): NonNullable<T>;
-    function notNull<T>(val: T, message: string, ...logs: any[]): NonNullable<T>;
-    function Null<T>(val: T, message: string, ...logs: any[]): T;
+    function notNull<T>(val: T, message?: string, ...logs: any[]): NonNullable<T>;
+    function Null<T>(val: T, message?: string, ...logs: any[]): T;
     function notEmpty<T extends string | Array<any> | {
         length: number;
     }>(val: T, message: string): NonNullable<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "dequanto",
-    "version": "0.2.49",
+    "version": "0.2.50",
     "author": {
         "name": "Alex Kit",
         "email": "alex.kit@atmajs.com"

package/src/abi/$abi.ts

@@ -1,7 +1,9 @@
-import { TAbiInput } from '@dequanto/types/TAbi';
+import { TAbiInput, TAbiItem, TAbiOutput } from '@dequanto/types/TAbi';
 import { ParamType } from './fragments';
 import { TEth } from '@dequanto/models/TEth';
 import { $abiCoder } from './$abiCoder';
+import { $abiUtils } from '@dequanto/utils/$abiUtils';
+import { $abiParser } from '@dequanto/utils/$abiParser';
 
 export namespace $abi {
     type TAbiType = string | ParamType | TAbiInput;
@@ -29,6 +31,37 @@ export namespace $abi {
         return isSingle ? result[0] : result;
     }
 
+    export function encodeCall(abi: string | TAbiItem, params?: any[]): TEth.Hex {
+        return $abiUtils.serializeMethodCallData(abi, params);
+    }
+
+    export function decodeReturn<T = any>(abi: string | TAbiItem | TAbiOutput[], hex: string): T {
+        let outputs = typeof abi === 'string'
+            ? ($abiParser.parseMethod(abi).outputs ?? [])
+            : (Array.isArray(abi) ? abi : abi.outputs ?? []);
+        let returnAbi = outputs;
+        let isDynamic: boolean = null;
+        if (outputs.length > 1) {
+            let isNamedTuple = outputs.every(x => x.name != null && x.name !== '');
+            if (isNamedTuple) {
+                returnAbi = [{ type: 'tuple', components: outputs, name: null }];
+                isDynamic = false;
+            }
+        }
+
+        try {
+            let arr = $abiCoder.decode(returnAbi as any, hex, {
+                dynamic: isDynamic
+            });
+            return returnAbi.length === 1 ? arr[0] : arr;
+        } catch (error) {
+            if (outputs.length === 1 && returnAbi.length === 1) {
+                return $abiCoder.decodeSingle(returnAbi[0], hex);
+            }
+            throw error;
+        }
+    }
+
     function ensureTypes (types: TAbiType | TAbiType[]): TAbiType[] {
         let arr = Array.isArray(types) ? types : [ types ];
         return arr.map($abiCoder.normalizeType);

package/src/blocks/BlockDateResolver.ts

@@ -1,9 +1,9 @@
 import alot from 'alot';
 import memd from 'memd';
-import { Web3Client } from '@dequanto/clients/Web3Client';
 import { TEth } from '@dequanto/models/TEth';
 import { $block } from '@dequanto/utils/$block';
 import { $date } from '@dequanto/utils/$date';
+import type { Web3Client } from '@dequanto/clients/Web3Client';
 
 export class BlockDateResolver {
     private AVG_INITIAL = {

package/src/clients/Web3Client.ts

@@ -32,6 +32,8 @@ import { DataLike } from '@dequanto/utils/types';
 import { ErrorCode } from './ClientPoolStats';
 import { $date } from '@dequanto/utils/$date';
 import { WalletClient } from './WalletClient';
+import alot from 'alot';
+import { $abiParser } from '@dequanto/utils/$abiParser';
 
 export abstract class Web3Client implements IWeb3Client {
 
@@ -108,12 +110,55 @@ export abstract class Web3Client implements IWeb3Client {
     }
 
     // Submit contract calls in a batch and decode the responses.
-    async batchContractCalls(requests: TRpcContractCall[], options?: {
+    async batchContractCalls(requests: TRpcContractCall[] | Promise<TRpcContractCall>[], options?: {
         allowErrors?: boolean
     }) {
         let reader = new RpcContract(this);
-        let result = await reader.batch(requests, options);
-        return result;
+
+        let requestsArrRaw = await Promise.all(requests);
+        let requestsArr = await alot(requestsArrRaw).mapAsync(async request => {
+            if (request == null) {
+                return null;
+            }
+            let abi = typeof request.abi === 'string'
+                ? [ $abiParser.parseMethod(request.abi) ]
+                : (Array.isArray(request.abi) ? request.abi : [ request.abi ])
+
+            let blockNumber = request.blockNumber;
+            if (blockNumber instanceof Date) {
+                let resolver = di.resolve(BlockDateResolver, this);
+                blockNumber = await resolver.getBlockNumberFor(blockNumber);
+            }
+            let method = request.method;
+            if (method == null) {
+                $require.eq(abi.length, 1, `No function method is provided, the single ABI item expected`);
+                method = abi[0].name;
+            }
+            return {
+                address: request.address,
+                abi: abi,
+                method: method,
+                params: request.params,
+                blockNumber: blockNumber,
+                options: options
+            } as TRpcContractCall;
+        }).toArrayAsync();
+
+        // Skip NULL request: mirror later as the NULL result
+        let mapped = [];
+        let rpcRequestsNotEmpty = [];
+        for (let i = 0; i < requestsArr.length; i++) {
+            if (requestsArr[i] == null) {
+                continue;
+            }
+            let idx = rpcRequestsNotEmpty.push(requestsArr[i]) - 1;
+            mapped[i] = idx;
+        }
+
+        let outputs = await reader.batch(rpcRequestsNotEmpty, options);
+        return requestsArr.map((_, i) => {
+            return outputs[mapped[i]] ?? null;
+        });
     }
 
     getEventStream(address: TEth.Address, abi: TAbiItem[], event: string) {

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/BlockchainExplorerFactory.ts

@@ -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/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/models/TPlatform.ts

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