dequanto 0.0.1 → 0.0.7

package/src/clients/PolyWeb3Client.ts

@@ -1,24 +1,22 @@
-import Common from '@ethereumjs/common'
 import { $config } from '@dequanto/utils/$config';
-import { FeeMarketEIP1559Transaction, Transaction,  TxData } from '@ethereumjs/tx'
 import { Web3Client } from './Web3Client';
 import { TPlatform } from '@dequanto/models/TPlatform';
 import { ClientEndpoints } from './utils/ClientEndpoints';
 import { IWeb3EndpointOptions } from './interfaces/IWeb3EndpointOptions';
 import { $bigint } from '@dequanto/utils/$bigint';
-import { TxFactory } from './utils/TxFactory';
 
 export class PolyWeb3Client extends Web3Client {
 
-
-
     platform: TPlatform = 'polygon';
-    chainId: number = 137;
+    chainId: number = this.options.chainId ?? 137;
     chainToken = 'MATIC';
     defaultGasLimit = 2_000_000;
 
     constructor (opts?: IWeb3EndpointOptions) {
-        super(ClientEndpoints.filterEndpoints($config.get('web3.polygon.endpoints'), opts));
+        super({
+            ...(opts ?? {}),
+            endpoints: ClientEndpoints.filterEndpoints($config.get('web3.polygon.endpoints'), opts)
+        });
     }
 
     async getGasPrice() {
@@ -41,51 +39,4 @@ export class PolyWeb3Client extends Web3Client {
         };
     }
 
-    // https://raw.githubusercontent.com/maticnetwork/launch/master/mainnet-v1/sentry/sentry/bor/genesis.json
-    // https://raw.githubusercontent.com/maticnetwork/launch/master/mainnet-v1/sentry/sentry/heimdall/config/genesis.json
-    sign(txData: TxData, privateKey: string): Buffer {
-
-        const key = Buffer.from(privateKey, 'hex');
-
-        const common = new Common({
-            chain: 137,
-            hardfork: 'london',
-            customChains: [
-                <any> {
-                    chainId: 137,
-                    networkId: 137,
-                    url: 'https://rpc-mainnet.maticvigil.com',
-                    name: 'MATIC',
-                    comment: '',
-                    hardforks: [
-                        {
-                            name: "spuriousDragon",
-                            block: 0
-                        },
-                        {
-                            name: 'berlin',
-                            block: 14750000
-                        },
-                        {
-                            name: 'london',
-                            block: 23850000
-                        }
-                    ],
-                    genesis: {
-                        hash: '0x0000000000000000000000000000000000000000000000000000000000000000',
-                        timestamp: '0x5ED20F84',
-                        difficulty: 0x1,
-                        gasLimit: 0x989680,
-                        nonce: '0x0',
-                        stateRoot: '',
-                        extraData: '',
-                    }
-                }
-            ]
-        });
-
-        const tx = TxFactory.fromTxData(txData as any, { common });
-        const signedTx = tx.sign(key);
-        return signedTx.serialize();
-    }
 }

package/src/clients/Web3Client.ts

@@ -1,15 +1,27 @@
+import di from 'a-di';
 import memd from 'memd';
 import Web3 from 'web3';
-import { TAddress } from '@dequanto/models/TAddress';
-import { TPlatform } from '@dequanto/models/TPlatform';
-import { TxData } from '@ethereumjs/tx';
-import { BlockHeader, BlockTransactionString, Syncing } from 'web3-eth';
-import { ClientPool, IPoolWeb3Request } from './ClientPool';
-import { ClientPoolTrace } from './ClientPoolStats';
-import { IWeb3Client } from './interfaces/IWeb3Client';
-import { Log, LogsOptions } from 'web3-core';
-import { Subscription } from 'web3-core-subscriptions';
+import { Wallet } from 'ethers';
 
+import type { AbiItem } from 'web3-utils';
+import type { TAddress } from '@dequanto/models/TAddress';
+import type { TPlatform } from '@dequanto/models/TPlatform';
+import type { TransactionRequest } from '@ethersproject/abstract-provider';
+import type { BlockTransactionString, Syncing } from 'web3-eth';
+import type { IWeb3Client, IWeb3ClientOptions } from './interfaces/IWeb3Client';
+import type { BlockNumber, Log, LogsOptions, PastLogsOptions, TransactionConfig, Transaction, TransactionReceipt, WebsocketProvider } from 'web3-core';
+import type { Subscription } from 'web3-core-subscriptions';
+import { ClientPool, IPoolClientConfig, IPoolWeb3Request } from './ClientPool';
+import { ClientPoolTrace } from './ClientPoolStats';
+import { BlockDateResolver } from '@dequanto/blocks/BlockDateResolver';
+import { $number } from '@dequanto/utils/$number';
+import { $txData } from '@dequanto/utils/$txData';
+import { $logger } from '@dequanto/utils/$logger';
+import { class_Dfr } from 'atma-utils';
+import { $promise } from '@dequanto/utils/$promise';
+import { ClientEventsStream } from './ClientEventsStream';
+import { $abiUtils } from '@dequanto/utils/$abiUtils';
+import { ClientDebugMethods } from './debug/ClientDebugMethods';
 
 export abstract class Web3Client implements IWeb3Client {
 
@@ -20,17 +32,59 @@ export abstract class Web3Client implements IWeb3Client {
     abstract chainToken: string;
     abstract defaultGasLimit: number;
 
-    abstract sign(txData: TxData, privateKey: string): Buffer
+    defaultTxType: 1 | 2 = 2;
+
+    async sign(txData: TransactionRequest, privateKey: string): Promise<string> {
+        let wallet = new Wallet(privateKey);
+        let json = $txData.getJson(txData, this);
+        let tx = await wallet.signTransaction(json);
+        return tx;
+    }
 
 
-    private pool = new ClientPool(this.config);
+    public options: IWeb3ClientOptions;
+    public pool: ClientPool;
+    public debug:ClientDebugMethods;
 
-    constructor (public config: { url: string }[] ) {
+    constructor (options: IWeb3ClientOptions)
+    constructor (endpoints: IPoolClientConfig[] )
+    constructor (mix: IWeb3ClientOptions | IPoolClientConfig[]) {
+        if (Array.isArray(mix)) {
+            this.options = { endpoints: mix }
+        } else if (mix != null) {
+            this.options = mix;
+        }
 
+        if (this.options.endpoints == null && this.options.web3 == null) {
+            console.dir(this.options, { depth: null });
+            throw new Error(`Neither Node endpoints nor web3 instance provided`);
+        }
+        this.pool = new ClientPool(this.options);
+        this.debug = new ClientDebugMethods(this, this.options.debug)
     }
 
-    getEventStream (address: TAddress, abi: any, event: string) {
-        return this.pool.getEventStream(address, abi, event);
+    getEventStream (address: TAddress, abi: AbiItem[], event: string) {
+        let eventAbi = abi.find(x => x.type === 'event' && x.name === event);
+        if (eventAbi == null) {
+            let events = abi.filter(x => x.type === 'event').map(x => x.name).join(', ');
+            throw new Error(`Event "${event}" not present in ABI. Events: ${ events }`);
+        }
+        let stream = new ClientEventsStream(address, eventAbi);
+        this
+            .subscribe('logs', {
+                address: address,
+                fromBlock: 'latest',
+                topics: [
+                    $abiUtils.getMethodHash(eventAbi)
+                ]
+            })
+            .then(subscription => {
+                stream.fromSubscription(subscription);
+            }, error => {
+                stream.error(error);
+            });
+
+        return stream;
     }
 
     with <TResult> (fn: (web3: Web3) => Promise<TResult>) {
@@ -57,25 +111,28 @@ export abstract class Web3Client implements IWeb3Client {
     ): Promise<Subscription<Syncing>>;
     subscribe(
         type: 'newBlockHeaders',
-        callback?: (error: Error, blockHeader: BlockHeader) => void
-    ): Promise<Subscription<BlockHeader>>;
+        callback?: (error: Error, blockHeader: BlockTransactionString) => void
+    ): Promise<Subscription<BlockTransactionString>>;
     subscribe(
         type: 'pendingTransactions',
         callback?: (error: Error, transactionHash: string) => void
     ): Promise<Subscription<string>>;
     async subscribe (...args): Promise<Subscription<any>>{
         let web3 = await this.getWeb3({ ws: true });
+
+        let provider = web3.eth.currentProvider as WebsocketProvider & { url };
+        if (provider.connected === false) {
+            provider.connect();
+            await $promise.waitForTrue(() => provider.connected, {
+                intervalMs: 200,
+                timeoutMessage: `Can not connect to ${provider.url}`,
+                timeoutMs: 20_000
+            });
+        }
         return web3.eth.subscribe(...args as Parameters<Web3['eth']['subscribe']>);
     }
 
-    readContract (data: {
-        address: TAddress,
-        abi: any
-        method: string,
-        arguments?: any[]
-        options?: { from?: string, },
-        blockNumber?: number
-    }) {
+    readContract (data: Web3BatchRequests.IContractRequest) {
         let { address, method, abi, options, blockNumber, arguments: params } = data;
         return this.pool.call(async web3 => {
             let contract = new web3.eth.Contract(abi, address);
@@ -94,6 +151,17 @@ export abstract class Web3Client implements IWeb3Client {
         });
     }
 
+    readContractBatch (requests: Web3BatchRequests.IContractRequest[]) {
+        let trace = new ClientPoolTrace();
+        trace.action = `Batch requests: ${ requests.map(x => x.address) }`;
+        return this.pool.call(async web3 => {
+            let batch = new Web3BatchRequests.BatchRequest(web3, requests);
+            return batch.execute();
+        }, {
+            trace
+        });
+    }
+
     encodeParameters (types: any[], paramaters: any[]) {
         return this.pool.callSync(web3 => {
             return web3.eth.abi.encodeParameters(types, paramaters);
@@ -106,6 +174,14 @@ export abstract class Web3Client implements IWeb3Client {
             return BigInt(weiStr);
         });
     }
+    getBalances (addresses: TAddress[], blockNumber?: number): Promise<bigint[]> {
+        return this.pool.call(async web3 => {
+            let reqs = addresses.map(address => cb => (web3.eth.getBalance as any).request(address, blockNumber, cb));
+            let batch = new Web3BatchRequests.BatchRequest<string>(web3, reqs);
+            let weiStrings = await batch.execute();
+            return weiStrings.map(weiStr => BigInt(weiStr));
+        });
+    }
     getTransactionCount(address: TAddress, type?: 'pending' | string) {
         return this.pool.call(web3 => {
             return web3.eth.getTransactionCount(address, type);
@@ -121,16 +197,67 @@ export abstract class Web3Client implements IWeb3Client {
             return web3.eth.getTransaction(txHash);
         }, opts);
     }
+    getTransactions (hashes: TAddress[], opts?: IPoolWeb3Request): Promise<Transaction[]> {
+        return this.pool.call(web3 => {
+            let reqs = hashes.map(hash => cb => (web3.eth.getTransaction as any).request(hash, cb));
+            let batch = new Web3BatchRequests.BatchRequest(web3, reqs);
+            return batch.execute();
+        }, opts);
+    }
     getTransactionReceipt (txHash: TAddress) {
         return this.pool.call(web3 => {
             return web3.eth.getTransactionReceipt(txHash);
         });
     }
+    getTransactionReceipts (hashes: TAddress[]): Promise<TransactionReceipt[]> {
+        return this.pool.call(web3 => {
+            let reqs = hashes.map(hash => cb => (web3.eth.getTransactionReceipt as any).request(hash, cb));
+            let batch = new Web3BatchRequests.BatchRequest(web3, reqs);
+            return batch.execute();
+        });
+    }
+    getTransactionTrace (hash: string) {
+        return this.pool.call(async web3 => {
+            let eth = web3.eth as (typeof web3.eth & { traceTransaction });
+
+            if (typeof eth.traceTransaction !== 'function') {
+                web3.eth.extend({
+                    methods: [
+                        {
+                            name: 'traceTransaction',
+                            call: 'debug_traceTransaction',
+                            params: 1,
+                        }
+                    ]
+                })
+            }
+
+            let result = await eth.traceTransaction(hash);
+            return result;
+
+        }, {
+            node: {
+                traceable: true
+            }
+        });
+    }
     getBlock (nr: number): Promise<BlockTransactionString> {
         return this.pool.call(web3 => {
             return web3.eth.getBlock(nr);
         });
     }
+    getBlocks (nrs: number[]): Promise<BlockTransactionString[]> {
+        return this.pool.call(web3 => {
+            let reqs = nrs.map(nr => cb => (web3.eth.getBlock as any).request(nr, cb));
+            let batch = new Web3BatchRequests.BatchRequest(web3, reqs);
+            return batch.execute();
+        });
+    }
+    getCode (address: TAddress) {
+        return this.pool.call(web3 => {
+            return web3.eth.getCode(address);
+        })
+    }
     getPendingTransactions () {
         return this.pool.call(web3 => {
             return web3.eth.getPendingTransactions();
@@ -162,7 +289,6 @@ export abstract class Web3Client implements IWeb3Client {
             }
         });
     }
-
     getStorageAt (address: TAddress, position: string | number | bigint, blockNumber?: number) {
         return this.pool.call(web3 => {
             return web3.eth.getStorageAt(address, <any> position, blockNumber);
@@ -177,7 +303,7 @@ export abstract class Web3Client implements IWeb3Client {
             });
         });
     }
-    getGasEstimation (from: TAddress, tx: TxData) {
+    getGasEstimation (from: TAddress, tx: TransactionRequest) {
         return this.pool.call(async web3 => {
             let txData = {
                 from: from,
@@ -190,12 +316,36 @@ export abstract class Web3Client implements IWeb3Client {
             return gasAmount;
         })
     }
+    async getAccounts (options?: IPoolWeb3Request): Promise<TAddress[]> {
+        let web3 = await this.getWeb3(options);
+        return web3.eth.getAccounts();
+    }
+    async getChainId (options?: IPoolWeb3Request): Promise<number> {
+        let web3 = await this.getWeb3(options);
+        return web3.eth.getChainId()
+    }
+
+    async switchChain (params: { chainId: number | string }, options: IPoolWeb3Request): Promise<any> {
+        let web3 = await this.getWeb3(options);
+        if (typeof (web3.eth.currentProvider as any).request !== 'function') {
+            throw new Error(`Current provider doesn't have request method`);
+        }
+        return (web3.eth.currentProvider as any).request({
+            method: 'wallet_switchEthereumChain',
+            params: [{ chainId: $number.toHex(params.chainId) }],
+        });
+    }
 
     sendSignedTransaction(signedTxBuffer: string) {
         return this.pool.callPromiEvent(web3 => {
             return web3.eth.sendSignedTransaction(signedTxBuffer);
         }, { preferSafe: true, distinct: true });
     }
+    sendTransaction(data: TransactionConfig) {
+        return this.pool.callPromiEvent(web3 => {
+            return web3.eth.sendTransaction(data);
+        }, { preferSafe: true, distinct: true });
+    }
 
     getBlockNumber () {
         return this.pool.call(web3 => {
@@ -210,6 +360,53 @@ export abstract class Web3Client implements IWeb3Client {
         });
     }
 
+    async getPastLogs (options: PastLogsOptions) {
+        const getBlock = async (block: BlockNumber | Date, $default: string | number) => {
+            if (block == null) {
+                return $default;
+            }
+            if (block instanceof Date) {
+                let resolver = di.resolve(BlockDateResolver, this);
+                return resolver.getBlockNumberFor(block);
+            }
+            return block;
+        };
+        const getBlockNumber = async (block: number | string) => {
+            if (typeof block === 'number') {
+                return block;
+            }
+            if (block == null || block === 'latest') {
+                return this.getBlockNumber();
+            }
+            if (block.startsWith('0x')) {
+                return Number(block);
+            }
+            throw new Error(`Invalid block number`);
+        };
+
+        options.fromBlock = await getBlock(options.fromBlock, 0);
+        options.toBlock = await getBlock(options.toBlock, 'latest');
+        options.topics = options.topics?.map(topic => {
+            if (typeof topic === 'string' && topic.startsWith('0x')) {
+                return '0x' + topic.substring(2).padStart(64, '0');
+            }
+            return topic;
+        });
+
+        let MAX = this.pool.getOptionForFetchableRange();
+        let [ fromBlock, toBlock ] = await Promise.all([
+            getBlockNumber(options.fromBlock as any),
+            getBlockNumber(options.toBlock as any),
+        ]);
+        return await RangeWorker.fetchWithLimits(this, options, {
+            maxBlockRange: MAX,
+            maxResultCount: null,
+        }, {
+            fromBlock,
+            toBlock
+        });
+    }
+
     getNodeInfos () {
         return this.pool.getNodeInfos();
     }
@@ -217,12 +414,213 @@ export abstract class Web3Client implements IWeb3Client {
         return this.pool.getNodeStats();
     }
 
-    static url<T extends Web3Client> (url: string): T {
+    static url<T extends Web3Client> (options: IWeb3ClientOptions)
+    static url<T extends Web3Client> (endpoints: IPoolClientConfig[], opts?: Partial<IWeb3ClientOptions>)
+    static url<T extends Web3Client> (url: string, opts?: Partial<IWeb3ClientOptions>): T
+    static url<T extends Web3Client> (mix: IWeb3ClientOptions | IPoolClientConfig[] | string, opts?: Partial<IWeb3ClientOptions>): T {
         const Ctor: any = this;
-        return new Ctor({
-            endpoints: [
-                { url }
-            ],
-        });
+        let options: IWeb3ClientOptions;
+        if (typeof mix === 'string') {
+            options = { endpoints: [ { url: mix }] }
+        } else if (Array.isArray(mix)) {
+            options = { endpoints: mix }
+        } else {
+            options = mix;
+        }
+        const param = {
+            ...options,
+            ...(opts ?? {})
+        };
+        return new Ctor(param);
+    }
+}
+
+
+namespace Web3BatchRequests {
+
+    export interface IContractRequest {
+        address: TAddress,
+        abi: any
+        method: string,
+        arguments?: any[]
+        options?: {
+            from?: TAddress
+        }
+        blockNumber?: number
+    }
+    export type IRequestBuilder = (cb: Function) => IRPCRequest
+
+    export interface IRPCRequest {
+        method: string
+        params: any
+        callback: Function
+    }
+
+    export function contractRequest (web3: Web3, request: IContractRequest, onComplete: Function) {
+        let { contract, method, params, callArgs } = prepair(web3, request);
+        return contract.methods[method](...params).call.request(...callArgs, onComplete);
+    }
+
+
+    export function call (web3: Web3, request: IContractRequest) {
+        let { contract, method, params, callArgs } = prepair(web3, request);
+        return contract.methods[method](...params).call(...callArgs);
+    }
+
+    export class BatchRequest<TReturnItem = any> {
+        private promise = new class_Dfr();
+        private results = new Array(this.requests.length);
+        private awaitables = this.requests.length;
+        //-private wasCompleted = false;
+
+        constructor (private web3: Web3, private requests: (IContractRequest | IRequestBuilder)[]) {
+
+        }
+        async execute (): Promise<TReturnItem[]> {
+            if (this.requests.length === 0) {
+                return this.promise.resolve(this.results);
+            }
+
+            let web3 = this.web3;
+            let batch = new web3.BatchRequest();
+            let arr = this.requests.map((req, i) => {
+                const cb = (err, result) => {
+                    this.onCompleted(i, err, result);
+                };
+                if (typeof req === 'function') {
+                    return req(cb);
+                }
+                return contractRequest(web3, req, cb);
+            });
+
+            arr.forEach(req => {
+                batch.add(req);
+            });
+            batch.execute();
+            return this.promise;
+        }
+
+        private onCompleted (i: number, error: Error, result?) {
+            this.results[i] = result ?? error;
+
+            if (--this.awaitables === 0) {
+                this.promise.resolve(this.results);
+            }
+        }
+    }
+
+    function prepair (web3: Web3, request: IContractRequest) {
+        let { address, method, abi, options, blockNumber, arguments: params } = request;
+        let contract = new web3.eth.Contract(abi, address);
+        let callArgs = [];
+        if (options != null) {
+            callArgs[0] = options;
+        }
+        if (blockNumber != null) {
+            callArgs[0] = null;
+            callArgs[1] = blockNumber;
+        }
+        return { contract, method, params, callArgs };
+    }
+}
+
+
+
+namespace RangeWorker {
+
+    export async function fetchWithLimits (
+        client: Web3Client,
+        options: PastLogsOptions,
+        limits: { maxBlockRange?: number, maxResultCount?: number },
+        ranges: { fromBlock: number, toBlock: number }
+    ) {
+        let { fromBlock, toBlock } = ranges;
+        let { maxBlockRange } = limits;
+        let range = toBlock - fromBlock;
+        if (maxBlockRange == null || range <= maxBlockRange) {
+            return fetch (client, options, ranges, limits);
+        }
+
+        let logs = [];
+        let cursor = fromBlock;
+        let pages = Math.ceil(range / maxBlockRange);
+        let page = 0;
+        let complete = false;
+        while (complete === false) {
+            ++page;
+            let end = cursor + maxBlockRange;
+            if (end > toBlock) {
+                end = options.toBlock as number;
+                complete = true;
+            }
+            $logger.log(`Get past logs paged: ${page}/${pages} (Block start: ${cursor}). Loaded ${logs.length}`);
+            let paged = await fetch(client, options, {
+                fromBlock: cursor,
+                toBlock: end ?? undefined,
+            }, limits);
+            logs.push(...paged);
+            cursor += maxBlockRange + 1;
+        }
+        return logs;
+
+    };
+
+
+    async function fetch (
+        client: Web3Client,
+        options: PastLogsOptions,
+        range: { fromBlock: number, toBlock: number },
+        knownLimits: { maxBlockRange?: number, maxResultCount?: number },
+    ) {
+        try {
+            let paged = await client.pool.call(web3 => web3.eth.getPastLogs({
+                ...options,
+                fromBlock: range.fromBlock,
+                toBlock: range.toBlock ?? undefined,
+            }));
+            return paged;
+        } catch (error) {
+            /**
+             * query returned more than 10000 results
+             */
+            $logger.log(`Range worker request: ${range.fromBlock}-${range.toBlock}. ${error.message.trim()}. Splitting range.`)
+            let matchCountLimit = /(?<count>\d+) results/.exec(error.message);
+            if (matchCountLimit) {
+                let count = Number(matchCountLimit.groups.count);
+
+                let half = Math.floor((range.toBlock - range.fromBlock) / 2);
+                let rangeA = {
+                    fromBlock: range.fromBlock,
+                    toBlock: range.fromBlock + half
+                };
+                let arr1 = await fetchWithLimits(client, options, {
+                    ...knownLimits,
+                    maxResultCount: count
+                }, rangeA);
+
+                let rangeB = {
+                    fromBlock: range.fromBlock + half,
+                    toBlock: range.toBlock
+                };
+                let arr2 = await fetchWithLimits(client, options, {
+                    ...knownLimits,
+                    maxResultCount: count
+                }, rangeB);
+
+                return [ ...(arr1 ?? []), ...(arr2 ?? []) ]
+            }
+
+            let maxRangeMatch = /\b(?<maxRange>\d+)\b/.exec(error.message);
+            if (maxRangeMatch && knownLimits.maxBlockRange == null) {
+                // handle unknown range, otherwise throw
+                let rangeLimit = Number(maxRangeMatch.groups.maxRange);
+                return await fetchWithLimits(client, options, {
+                    ...knownLimits,
+                    maxBlockRange: rangeLimit
+                }, range);
+            }
+
+            throw error;
+        }
     }
 }

package/src/clients/Web3ClientFactory.ts

@@ -6,22 +6,38 @@ import { IWeb3EndpointOptions } from './interfaces/IWeb3EndpointOptions';
 import { PolyWeb3Client } from './PolyWeb3Client';
 import { ArbWeb3Client } from '@dequanto/chains/arbitrum/ArbWeb3Client';
 import { XDaiWeb3Client } from '@dequanto/chains/xdai/XDaiWeb3Client';
+import { HardhatProvider } from '@dequanto/hardhat/HardhatProvider';
+import { config } from '@dequanto/Config';
+import { $require } from '@dequanto/utils/$require';
+import { EvmWeb3Client } from './EvmWeb3Client';
 
 export namespace Web3ClientFactory {
 
-    export function get (platform: TPlatform, opts?: IWeb3EndpointOptions) {
+    export function get (platform: TPlatform | string, opts?: IWeb3EndpointOptions) {
         switch (platform) {
             case 'bsc':
                 return di.resolve(BscWeb3Client, opts);
             case 'eth':
                 return di.resolve(EthWeb3Client, opts);
+            case 'eth:goerli':
+                return di.resolve(EthWeb3Client, {
+                    platform: platform,
+                    chainId: 5,
+                    ...(opts ?? {})
+                });
             case 'polygon':
                 return di.resolve(PolyWeb3Client, opts);
             case 'arbitrum':
                 return di.resolve(ArbWeb3Client, opts);
             case 'xdai':
                 return di.resolve(XDaiWeb3Client, opts);
+            case 'hardhat':
+                return di.resolve(HardhatProvider).client('localhost');
             default:
+                let cfg = config.web3[platform];
+                if (cfg != null) {
+                    return new EvmWeb3Client({ platform, ...cfg });
+                }
                 throw new Error(`Unsupported platform ${platform} for web3 client`);
         }
     }