dequanto 0.0.1 → 0.1.3

package/src/clients/ClientPool.ts

@@ -1,61 +1,159 @@
 import alot from 'alot';
 import memd from 'memd';
-import Web3 from 'web3';
-import { AbiItem } from 'web3-utils';
 import { $date } from '@dequanto/utils/$date';
 import { $number } from '@dequanto/utils/$number';
-import { PromiEvent } from 'web3-core';
-import { PromiEventWrap } from './model/PromiEventWrap';
+import { $require } from '@dequanto/utils/$require';
+import { $contract } from '@dequanto/utils/$contract';
+import { $logger, l } from '@dequanto/utils/$logger';
+import { $promise } from '@dequanto/utils/$promise';
+import { $array } from '@dequanto/utils/$array';
+import { $bigint } from '@dequanto/utils/$bigint';
+
+import { PromiseEventWrap } from './model/PromiEventWrap';
 import { IWeb3ClientStatus } from './interfaces/IWeb3ClientStatus';
 import { ClientStatus } from './model/ClientStatus';
-import { ClientPoolTrace, ClientPoolTraceError } from './ClientPoolStats';
-import { class_Dfr } from 'atma-utils';
-import { TAddress } from '@dequanto/models/TAddress';
-import { ClientEventsStream } from './ClientEventsStream';
-import { Subscription } from 'web3-core-subscriptions';
+import { ClientPoolTrace, ClientPoolTraceError, ErrorCode } from './ClientPoolStats';
+import { class_Dfr, obj_extendDefaults } from 'atma-utils';
 import { ClientErrorUtil } from './utils/ClientErrorUtil';
-import { $fn } from '@dequanto/utils/$fn';
-import { $promise } from '@dequanto/utils/$promise';
+import { IWeb3ClientOptions } from './interfaces/IWeb3Client';
+import { RateLimitGuard } from './handlers/RateLimitGuard';
+import { Web3BatchRequests } from './Web3BatchRequests';
+
+import { HttpTransport } from '@dequanto/rpc/transports/HttpTransport';
+import { WsTransport } from '@dequanto/rpc/transports/WsTransport';
+import { Rpc } from '@dequanto/rpc/Rpc';
+
+import { Web3Transport } from '@dequanto/rpc/transports/compatibility/Web3Transport';
+import { PromiseEvent } from '@dequanto/class/PromiseEvent';
+import { TTransport } from '@dequanto/rpc/transports/ITransport';
+
+import { TRpc } from '@dequanto/rpc/RpcBase';
+import { TEth } from '@dequanto/models/TEth';
+import { $rpc } from '@dequanto/rpc/$rpc';
+import { Web3 } from './compatibility/Web3';
 
+export interface IPoolClientConfig {
+    url?: string
+    options?: TTransport.Options.Http | TTransport.Options.Ws
 
-interface IPoolClientConfig {
-    url: string
+    /** Will be a pefered node for submitting transactions */
     safe?: boolean
     distinct?: boolean
+
+    web3?: TTransport.Transport
+
+    name?: string
+    /** Will be used only if manually requested with .getWeb3, or .getNodeUrl */
+    manual?: boolean
+
+    /** max block range per request when getting for example the past logs*/
+    fetchableBlockRange?: number
+
+    /** True if the node supports traceTransaction calls */
+    traceable?: boolean
+
+    // requestCout/timeSpan: e.g. 100/1min
+    rateLimit?: string
+
+    // the max block range to fetch per single request when getting Logs
+    blockRangeLimit?: string | number
+
+    // maximum of requests to be batched, otherwise batches will be paginated
+    batchLimit?: number
+
+    // Will be used only for the specified methods
+    methods?: {
+        exclude?: string[]
+        only?: string[]
+    }
 }
 export interface IPoolWeb3Request {
     ws?: boolean
     preferSafe?: boolean
     distinct?: boolean
+    name?: string
+
+    /** HTTP Web3 Client traces */
     trace?: ClientPoolTrace
+
+    /** Supported node features */
+    node?: {
+        // For specific url
+        url?: string
+
+        /** Supports traceTransaction */
+        traceable?: boolean
+    }
+
+    /** RPC method - will find the node that has the configuration */
+    method?: string
+
+    // Amount of batch requests to be performed, sothat we can choose the appropriate wClient and handle the rate limits correctly
+    batchRequestCount?: number
+
+    // By fetching logs, specifies the desired block range to query
+    blockRangeCount?: number
 }
+
 export class ClientPool {
 
     private discoveredPartial = false;
     private discoveredFull = false;
-    private clients = this.config.map(cfg => new WClient(cfg));
+    private clients: WClient[];
     private ws: WClient;
 
-    constructor (public config: { url: string }[] ) {
+    /** Minimum rate limit range to assume the RPC is alive */
+    MINIMUM_BLOCK_RANGE = 200
+
+    constructor(config: IWeb3ClientOptions) {
 
+        if (config.endpoints != null && config.endpoints.length > 0) {
+            this.clients = config.endpoints.map(cfg => new WClient(cfg))
+        } else if (config.web3 || config.provider) {
+            this.clients = [new WClient({ web3: config.web3 ?? config.provider })];
+        } else {
+            console.dir(config, { depth: null });
+            throw new Error(`Neither Node endpoints nor Web3 instance`)
+        }
         if (this.clients.length < 2) {
             this.discoveredPartial = true;
             this.discoveredFull = true;
         }
     }
 
-    callSync <TResult> (fn: (web3: Web3) => TResult ): TResult {
+    // callSync<TResult>(fn: (web3: Web3) => TResult): TResult {
 
-        let arr = this.clients.filter(x => x.status === 'ok');
-        let wClient = arr[ $number.randomInt(0, arr.length) ];
-        let { status, result } = wClient.callSync(fn);
-        if (status == ClientStatus.Ok) {
-            return result;
-        }
-        throw result;
+    //     let arr = this.clients.filter(x => x.status === 'ok');
+    //     let wClient = arr[$number.randomInt(0, arr.length)];
+    //     let { status, result } = wClient.callSync(fn);
+    //     if (status == ClientStatus.Ok) {
+    //         return result;
+    //     }
+    //     throw result;
+    // }
+
+    async callBatched(data: {
+        requests: (rpc: Rpc) => Promise<Web3BatchRequests.IRpcRequest[]>
+        map?: (results: any[]) => any
+    }, opts?: IPoolWeb3Request) {
+        return this.call(async (wClient) => {
+            let requests = await data.requests(wClient.rpc);
+            let results = await wClient.callBatched(requests);
+            let mapped = data?.map?.(results) ?? results;
+            return mapped;
+        }, {
+            ...(opts ?? {}),
+
+            /**
+             * web3@1.6.0 has a bug with batch request via websockets, as the callback can stuck if a single response contains multiple IDs, as only the first one will be taken
+             * https://github.com/web3/web3.js/blob/9238e106294784b4a6a20af020765973f0437022/packages/web3-providers-ws/src/index.js#L128
+            */
+            ws: false
+        });
     }
 
-    async call <TResult> (fn: (web3: Web3) => Promise<TResult>, opts?: IPoolWeb3Request): Promise<TResult> {
+    async call<TResult>(fn: (wClient: WClient) => Promise<TResult>, opts?: IPoolWeb3Request): Promise<TResult> {
+        // Client - Retries
         let used = new Map<WClient, number>();
         let errors = [];
 
@@ -71,55 +169,94 @@ export class ClientPool {
 
                     error = new Error(`Live clients not found in \n${urls}`);
                 }
-                throw ClientPoolTraceError.create(error, opts?.trace);
+                throw ClientPoolTraceError.create(error, opts?.trace, ErrorCode.NO_LIVE_CLIENT);
             }
-            let { status, result, error, time } = await wClient.call(fn);
 
+            let wClientUsage = used.get(wClient);
+            let { status, result, error, time } = await wClient.call(fn, opts);
+
+            if (error != null && error.data != null) {
+                error.data = $contract.decodeCustomError(error.data, []);
+            }
             opts
                 ?.trace
                 ?.onComplete({ status, error, time, url: wClient.config.url })
 
-            used.set(wClient, 1);
+
+            if (wClientUsage == null) {
+                // per default NO_RETRIES
+                used.set(wClient, 0);
+            } else {
+                // decrease retry count
+                used.set(wClient, wClientUsage - 1);
+            }
+
             errors.push(error ?? result);
 
             if (status == ClientStatus.Ok) {
                 return result;
             }
+            if (status == ClientStatus.RateLimited) {
+                if (wClientUsage == null) {
+                    const RETRIES = 5;
+                    used.set(wClient, RETRIES);
+                }
+            }
             if (status === ClientStatus.CallError) {
-                let error = ClientPoolTraceError.create(errors.pop(), opts?.trace);
-                //console.log(`Errored ${error.message}`);
+                let error = ClientPoolTraceError.create(errors.pop(), opts?.trace, ErrorCode.CALL);
                 throw error;
                 return result;
             }
+
+            // if not the CallError, process the while loop to check another NodeProvider
         }
     }
-    async getWeb3 (options?: IPoolWeb3Request) {
-        let wClient = await this.next(null, options);
+    async getRpc(options?: IPoolWeb3Request) {
+        let wClient = await this.getWrappedWeb3(options);
+        return wClient?.rpc;
+    }
+    async getWrappedWeb3(options?: IPoolWeb3Request) {
+        let wClient = await this.next(null, options, { manual: true });
         if (wClient == null) {
-            throw new Error(`Not client found in ${this.clients.length} Clients`);
+            throw new Error(`No client found in ${this.clients.length} Clients with options: ${JSON.stringify(options)}`);
         }
-        return wClient?.web3;
+        return wClient;
     }
-    async getNodeURL (options?: IPoolWeb3Request) {
-        let wClient = await this.next(null, options);
+    async getNodeURL(options?: IPoolWeb3Request) {
+        let wClient = await this.next(null, options, { manual: true });
         if (wClient == null) {
-            throw new Error(`Not client found in ${this.clients.length} Clients`);
+            let stats = await this.getNodeStats();
+            let info = stats.map(x => `    ${x.url}. ERR: ${x.fail}; OK: ${x.success}; Ping: ${x.ping}`).join('\n');
+            let requirements = JSON.stringify(options);
+            throw new Error(`No alive node for ${requirements} found. \n ${info}`);
         }
         return wClient?.config.url;
     }
-    async releaseWeb3 () {
+    async releaseWeb3() {
 
     }
 
-    callPromiEvent <TResult extends PromiEvent<any>> (
-        fn: (web3: Web3) => TResult
+    getOptionForFetchableRange(blockRangeLimits?: WClient['blockRangeLimits']): number {
+        const DEFAULT = blockRangeLimits?.blocks;
+        let max = alot(this.clients).max(x => x.config?.fetchableBlockRange ?? 0);
+        if (max === 0) {
+            return DEFAULT;
+        }
+        if (typeof DEFAULT === 'number') {
+            return Math.min(DEFAULT, max);
+        }
+        return max;
+    }
+
+    callPromiEvent<TResult extends PromiseEvent<any>>(
+        fn: (web3: WClient) => TResult
         , opts?: { preferSafe?: boolean, parallel?: number, silent?: boolean, distinct?: boolean }
-        , used:  Map<WClient, number> = new  Map<WClient, number>()
+        , used: Map<WClient, number> = new Map<WClient, number>()
         , errors = []
-        , root?: PromiEventWrap
+        , root?: PromiseEventWrap
     ): TResult {
 
-        root = root ?? new PromiEventWrap();
+        root = root ?? new PromiseEventWrap();
 
         (async () => {
             let wClient = await this.next(used, opts);
@@ -141,12 +278,11 @@ export class ClientPool {
                 return root as any as TResult;
             }
 
-            let promiEvent = wClient.callPromiEvent(fn);
+            let promiseEvent = wClient.callPromiEvent(fn);
 
-            root.bind(promiEvent);
+            root.bind(promiseEvent);
 
-            promiEvent.on('error', async error => {
-                console.log('!!client ERROR', error);
+            promiseEvent.on('error', async error => {
                 error.message += ` (RPC: ${wClient.config.url})`;
                 if (ClientErrorUtil.isConnectionFailed(error)) {
                     this.callPromiEvent(
@@ -155,23 +291,16 @@ export class ClientPool {
                     return;
                 }
                 if (ClientErrorUtil.isAlreadyKnown(error)) {
-                    console.log(`TxWriter ERROR ${error.message}. Check pending...`);
-                    let web3 = await this.getWeb3();
-                    let txs = await web3.eth.getPendingTransactions();
-                    console.log('PENDING ', txs?.map(x => x.hash));
-                    // throw anyways
-                    // this.callPromiEvent(
-                    //     fn, opts, used, errors, root
-                    // );
-                    // return;
+                    $logger.log(`TxWriter ERROR ${error.message}. Check pending...`);
+                    let rpc = await this.getRpc();
+                    let txs = await rpc.eth_pendingTransactions();
+                    $logger.log('PENDING ', txs?.map(x => x.hash));
+                    // throw anyway
                 }
                 root.emit('error', error);
                 root.reject(error);
             });
-            promiEvent.catch(error => {
-                console.log('!!client CATCH', error);
-                //root.reject(error);
-            });
+
 
             used.set(wClient, 1);
 
@@ -196,15 +325,15 @@ export class ClientPool {
         return root as any as TResult;
     }
 
-    getEventStream (address: TAddress, abi: any, event: string) {
-        if (this.ws == null) {
-            this.ws = this.clients.find(x => x.config.url.startsWith('ws'));
-        }
-        let stream = this.ws.getEventStream(address, abi, event);
-        return stream;
-    }
+    // getEventStream (address: TAddress, abi: TAbiItem[], event: string) {
+    //     if (this.ws == null) {
+    //         this.ws = this.clients.find(x => x.config.url?.startsWith('ws'));
+    //     }
+    //     let stream = this.ws.getEventStream(address, abi, event);
+    //     return stream;
+    // }
 
-    getNodeStats () {
+    getNodeStats() {
         return this
             .clients
             .filter(client => client.getRequestCount() > 0)
@@ -216,34 +345,79 @@ export class ClientPool {
             });
     }
 
-    async getNodeInfos (): Promise<IWeb3ClientStatus[]> {
+    async getNodeInfos(options?: {
+        timeout?: number
+        calls?: ('net_peerCount' | 'eth_blockNumber' | 'eth_syncing' | 'net_version')[]
+    }): Promise<IWeb3ClientStatus[]> {
+        const Calls = {
+            async net_peerCount(wClient: WClient) {
+                /** @TODO Public nodes smt. do not allow net_peerCount methods. Allow to switch this on/off on node-url-config level */
+                try {
+                    return await wClient.rpc.net_peerCount();
+                } catch (error) {
+                    return `ERROR: ${error.message}`;
+                }
+            },
+            async eth_syncing(wClient: WClient): Promise<IWeb3ClientStatus['syncing']> {
+                let syncing = await wClient.rpc.eth_syncing();
+                if (syncing == null || typeof syncing === 'boolean') {
+                    return null;
+                }
+                return syncing as any;
+            },
+            async net_version(wClient: WClient): Promise<IWeb3ClientStatus['node']> {
+                return await wClient.rpc.net_version()
+            },
+            async eth_blockNumber(wClient: WClient): Promise<IWeb3ClientStatus['blockNumber']> {
+                return await wClient.rpc.eth_blockNumber()
+            }
+        } as const;
+
+
+        async function query<TReturn extends Promise<any>>(wClient: WClient, method: (wClient: WClient) => TReturn): Promise<TReturn> {
+            let methodName = method.name;
+            let shouldCall = methodName === 'eth_blockNumber' || options?.calls == null || options?.calls.includes(methodName as any);
+            if (shouldCall === false) {
+                return null;
+            }
+            let promise = method(wClient);
+            return options?.timeout == null ? promise : $promise.timeout(promise, options.timeout);
+        }
+
         let nodes = await alot(this.clients).mapAsync(async (wClient, idx) => {
 
             let url = wClient.config.url;
             try {
                 let start = Date.now();
-                let [ syncing, blockNumber, peers ] = await Promise.all([
-                    wClient.eth.isSyncing(),
-                    wClient.eth.getBlockNumber(),
-                    /** @TODO Public nodes smt. do not allow net_peerCount methods. Allow to switch this on/off on node-url-config level */
-                    wClient.eth.net.getPeerCount(),
+                let [syncing, blockNumberUint, peers, node] = await Promise.all([
+                    query(wClient, Calls.eth_syncing),
+                    query(wClient, Calls.eth_blockNumber),
+                    query(wClient, Calls.net_peerCount),
+                    query(wClient, Calls.net_version),
                 ]);
+                let blockNumber = Number(blockNumberUint);
 
-                let ping = Math.round((Date.now() - start) / 3);
-                let syncData = typeof syncing === 'boolean' ? null : syncing;
-                return <IWeb3ClientStatus>  {
+                let ping = Math.round((Date.now() - start) / 4);
+                let blockNumberBehind = 0;
+                if (syncing?.currentBlock && syncing.currentBlock < blockNumber) {
+                    blockNumberBehind = blockNumber - Number(syncing.currentBlock);
+                    blockNumber = Number(syncing.currentBlock);
+                }
+
+                return <IWeb3ClientStatus>{
                     url: url,
-                    status: 'live',
-                    syncing: <any> syncData,
+                    status: syncing ? 'sync' : (isNaN(blockNumber) ? 'off':  'live'),
+                    syncing: syncing,
                     blockNumber: blockNumber,
-                    blockNumberBehind: 0,
-                    peers: peers,
+                    blockNumberBehind: blockNumberBehind,
+                    peers: Number(peers),
                     pingMs: ping,
+                    node: node,
                     i: idx,
                 };
 
             } catch (error) {
-                return <IWeb3ClientStatus> {
+                return <IWeb3ClientStatus>{
                     url,
                     status: 'error',
                     error: error,
@@ -261,57 +435,53 @@ export class ClientPool {
         return nodes;
     }
 
-    // callSubscribtion <TResult> (
-    //     event: any
-    //     , cb: (error, result) => void
-    //     , opts?: { preferSafe?: boolean }
-    //     , used:  Map<WClient, number> = new  Map<WClient, number>()
-    //     , errors = []
-    //     , root?: PromiEventWrap
-    // ) {
-    //     root = root ?? new PromiEventWrap();
-
-    //     let wClient = this.next(used);
-    //     if (wClient == null) {
-    //         setTimeout(() => {
-    //             let error = new Error('Clients not found');
-    //             root.emit('error', error);
-    //             root.reject(error);
-    //         });
-    //         return root as any as TResult;
-    //     }
-
-    //     let promiEvent = wClient.callSubscription(fn);
-
-    //     root.bind(promiEvent);
-
-    //     promiEvent.on('error', error => {
-    //         if (ErrorUtil.isConnectionFailed(error)) {
-    //             this.callPromiEvent(
-    //                 fn, opts, used, errors, root
-    //             );
-    //             return;
-    //         }
-    //         root.emit('error', error);
-    //         root.reject(error);
-    //     });
-
-    //     used.set(wClient, 1);
-    //     return root as any as TResult;
-    // }
+    private async next(used?: Map<WClient, number>, opts?: IPoolWeb3Request, params?: { manual?: boolean }): Promise<WClient> {
+        let clients = this.clients;
+        if (params?.manual !== true) {
+            clients = clients.filter(x => x.config.manual !== true);
+        }
+        if (opts?.method != null) {
+            let clientsWithSupportedMethod = clients.filter(x => {
+                let methods = x.config.methods;
+                if (methods == null) {
+                    return false;
+                }
+                if (methods.exclude?.includes(opts.method) === true) {
+                    return false;
+                }
+                if (methods.only != null) {
+                    return methods.only.includes(opts.method) === true;
+                }
+                return true;
+            });
+            if (clientsWithSupportedMethod.length > 0) {
+                // if there are no clients with manually specified method, use all clients
+                clients = clientsWithSupportedMethod;
+            }
+        } else {
+            // Unspecified method, so exclude clients with specific methods
+            clients = clients.filter(x => x.config.methods == null);
+        }
 
-    private async next (used?: Map<WClient, number>, opts?: IPoolWeb3Request): Promise<WClient> {
         if (opts?.ws === true) {
             if (this.ws == null) {
-                this.ws = this.clients.find(x => x.config.url.startsWith('ws'));
+                this.ws = clients.find(x => x.config.url?.startsWith('ws'));
+            }
+            if (this.ws == null) {
+                this.ws = clients.find(x => x.config.web3 != null);
             }
             return this.ws;
         }
 
-        let clients = this.clients;
-
         if (opts?.ws === false) {
-            clients = this.clients.filter(x => x.config.url.startsWith('http'));
+            // filter out all WS providers (important for batched requests, as web3js has issues submitting multiple batch requests and handle response IDs)
+            clients = clients.filter(x => x.config.url?.startsWith('http') || x.config.url == null);
+        }
+        if (opts?.node?.traceable === true) {
+            clients = clients.filter(x => x.config.traceable === true);
+        }
+        if (opts?.node?.url != null) {
+            clients = clients.filter(x => x.config.url === opts.node.url);
         }
 
         if (this.discoveredPartial === false) {
@@ -320,7 +490,7 @@ export class ClientPool {
         }
 
         // we check OK clients first
-        let okClients = clients.filter(x => x.status === 'ok' );
+        let okClients = clients.filter(x => x.status === 'ok');
         if (okClients.length === 0) {
             // then switch to at least not off
             let notOffClients = clients.filter(x => x.status !== 'off');
@@ -333,7 +503,7 @@ export class ClientPool {
 
         let available = used == null
             ? clients
-            : clients.filter(x => used.has(x) === false);
+            : clients.filter(x => used.has(x) === false || used.get(x) > 0);
 
         if (available.length === 0) {
             if (this.discoveredFull === false) {
@@ -344,7 +514,7 @@ export class ClientPool {
             }
             return null;
         }
-        let healthy = available.filter(x =>  x.healthy());
+        let healthy = available.filter(x => x.healthy());
 
         if (opts?.preferSafe === true) {
             let safe = healthy.filter(x => x.config.safe === true);
@@ -362,9 +532,53 @@ export class ClientPool {
         let arr = healthy.length > 0
             ? healthy
             : available;
-        let i = $number.randomInt(0, arr.length);
-        let client = arr[i];
-        return client;
+
+        if (opts?.blockRangeCount != null) {
+            let upperThreshold = alot(arr).max(x => x.blockRangeLimits.blocks) * .5;
+            arr = arr.filter(x => {
+                let blocks = x.blockRangeLimits.blocks;
+                if (blocks == null) {
+                    // Block limit is unknown yet
+                    return true;
+                }
+                if (blocks < this.MINIMUM_BLOCK_RANGE) {
+                    // Was not possible to load a minimum amount of blocks
+                    return false;
+                }
+                // Get if higher than 50% of max supported limit
+                return x.blockRangeLimits.blocks >= upperThreshold
+            });
+        }
+        return await this.getClientWithLowestWaitTime(arr);
+    }
+
+
+    private async getClientWithLowestWaitTime(clients: WClient[]): Promise<WClient> {
+        if (clients.length === 0) {
+            return null;
+        }
+
+        clients = $array.shuffle(clients);
+
+        let minWait = Infinity;
+        let minClient: WClient = null;
+        for (let i = 0; i < clients.length; i++) {
+            let client = clients[i];
+            let waitMs = client.getRateLimitGuardTime();
+            if (waitMs === 0) {
+                return client;
+            }
+            if (minWait > waitMs) {
+                minWait = waitMs;
+                minClient = client;
+            }
+        }
+
+        const MAX_WAIT = 60_000;
+        if (minWait > MAX_WAIT) {
+            throw new Error(`rate limit overflows. Waiting ${minWait}ms`);
+        }
+        return minClient;
     }
 
     /**
@@ -375,7 +589,7 @@ export class ClientPool {
      * - Complete Promise - when all clients are resolved
      */
     @memd.deco.memoize({ perInstance: true })
-    private discoverLive (): { ready: class_Dfr, completed: class_Dfr } {
+    private discoverLive(): { ready: class_Dfr, completed: class_Dfr } {
 
         this.clients.forEach(x => x.status = 'ping');
 
@@ -397,17 +611,17 @@ export class ClientPool {
         (async () => {
             let nodeInfosAsync = clients.map(async (wClient, idx) => {
                 try {
-                    let clientInfo = {
+                    let clientInfo = <TClientInfo>{
                         i: idx,
                         error: null,
                         status: null,
                         blockNumberBehind: 0,
-                        blockNumber: await $fn.timeoutPromise(wClient.eth.getBlockNumber(), 20_000)
+                        blockNumber: await $promise.timeout(wClient.rpc.eth_blockNumber(), 20_000)
                     };
                     onIntermediateSuccess(clientInfo);
                     return clientInfo;
                 } catch (error) {
-                    return <TClientInfo> {
+                    return <TClientInfo>{
                         i: idx,
                         error: error,
                         status: 'off',
@@ -423,6 +637,7 @@ export class ClientPool {
                 let messages = nodeInfos.map(x => {
                     let url = clients[x.i]?.config.url;
                     let message = x.error?.message;
+                    console.log(`Stack`, x.error?.stack);
                     return `  ${url}: ${message}`;
                 }).join('\n');
 
@@ -435,8 +650,8 @@ export class ClientPool {
 
             const blockLatest = alot(nodeInfos).max(x => x.blockNumber);
 
-            nodeInfos.forEach(node => {
-                node.blockNumberBehind = node.blockNumber - blockLatest;
+            nodeInfos.forEach(info => {
+                info.blockNumberBehind = info.blockNumber - blockLatest;
             });
             nodeInfos.forEach(info => {
                 this.clients[info.i].status = isOk(info);
@@ -450,23 +665,24 @@ export class ClientPool {
             }
         })();
 
-        function isOk (info: TClientInfo): WClient['status'] {
+        function isOk(info: TClientInfo): WClient['status'] {
             if (info.error) {
                 return 'off';
             }
-            if (isNaN(info.blockNumber) || info.blockNumberBehind < -200) {
+            if (info.blockNumber == null || info.blockNumberBehind < -200n) {
                 return 'off';
             }
             return 'ok';
         }
-        function onIntermediateSuccess (info: TClientInfo) {
-            const TOLERATE_BLOCK_COUNT = 5;
+        function onIntermediateSuccess(info: TClientInfo) {
+            const TOLERATE_BLOCK_COUNT = 5n;
             const WAIT_POOL_OK = Math.min(3, clientInfos.length);
+            const count = clientInfos.push(info);
 
             if (isReady === true) {
                 return;
             }
-            if (clientInfos.push(info) < WAIT_POOL_OK) {
+            if (count < WAIT_POOL_OK) {
                 return;
             }
 
@@ -480,8 +696,9 @@ export class ClientPool {
             }
             if (ok.length >= WAIT_POOL_OK) {
                 ok.forEach(info => {
-                    clients[info.i].status = 'ok';
+                    clients[info.i].status = info.status = 'ok';
                 });
+
                 isReady = true;
                 ready.resolve();
             }
@@ -491,9 +708,9 @@ export class ClientPool {
     }
 }
 
-class WClient {
+export class WClient {
     lastStatus = 0;
-    lastDate: Date = new Date(2000);
+    lastDate = new Date(2000).getTime();
 
     status: 'ok' | 'off' | 'ping' = 'ok'
 
@@ -503,10 +720,21 @@ class WClient {
         ping: 0
     };
 
-    web3: Web3
-    eth: Web3['eth']
+    rpc: Rpc
+
+    config: IPoolClientConfig
+    rateLimitGuard: RateLimitGuard
 
-    healthy () {
+    /** For getLogs method, as some providers limit the range request or page result value */
+    blockRangeLimits: {
+        blocks?: number
+        results?: number
+    }
+
+    // Max requests per single Web3 Batch request
+    batchLimit?: number
+
+    healthy() {
         if (this.getRequestCount() === 0) {
             return true;
         }
@@ -517,21 +745,91 @@ class WClient {
         if (health > .5) {
             return true;
         }
-        if (Date.now() - this.lastDate.getTime() > $date.parseTimespan('10m')) {
+        if (Date.now() - this.lastDate > $date.parseTimespan('10m')) {
             return true;
         }
         return false;
     }
 
-    constructor (public config: IPoolClientConfig) {
-        this.web3 = new Web3(config.url);
-        this.web3.eth.handleRevert = true;
-        this.eth = this.web3.eth;
+    private updateRateLimitInfo(info: ReturnType<typeof RateLimitGuard['extractRateLimitFromError']>) {
+        if (this.rateLimitGuard == null) {
+            this.rateLimitGuard = new RateLimitGuard({
+                id: this.config.url ?? 'web3',
+                rates: []
+            });
+        }
+        this.rateLimitGuard.updateRateLimitInfo(info);
     }
+    public updateBlockRangeInfo(info: WClient['blockRangeLimits']) {
+        if (this.blockRangeLimits == null) {
+            this.blockRangeLimits = {};
+        }
+        if (info.blocks != null) {
+            this.blockRangeLimits.blocks = info.blocks;
+        }
+        if (info.results != null) {
+            this.blockRangeLimits.results = info.results;
+        }
+    }
+
+    constructor(mix: IPoolClientConfig) {
+        const hasUrl = 'url' in mix && typeof mix.url === 'string';
+        const hasWeb3 = 'web3' in mix && typeof mix.web3 != null;
+        if (hasUrl || hasWeb3) {
+            this.config = mix;
+            let transport = mix as TTransport.Options.Any;
+            this.rpc = new Rpc(transport);
+        } else {
+            throw new Error(`Neither Node URL nor Web3 Instance in argument`);
+        }
+
+        this.blockRangeLimits = { blocks: Infinity };
+
+        if (mix.rateLimit) {
+            let rates = RateLimitGuard.parseRateLimit(mix.rateLimit);
+            this.rateLimitGuard = new RateLimitGuard({
+                id: this.config?.url ?? 'web3',
+                rates: rates
+            })
+        }
+        if (mix.blockRangeLimit) {
+            this.updateBlockRangeInfo({
+                blocks: $number.parse(mix.blockRangeLimit)
+            })
+        }
+        if (mix.batchLimit) {
+            this.batchLimit = $number.parse(mix.batchLimit);
+        }
+        if (mix.fetchableBlockRange) {
+            this.updateBlockRangeInfo({
+                blocks: $number.parse(mix.fetchableBlockRange)
+            });
+        }
+    }
+
+
+    // @memd.deco.memoize()
+    // private createWebSocketClient(url: string) {
+    //     let { options } = this.config;
+
+    //     // options = obj_extendDefaults(options ?? {}, { clientConfig: {} });
+    //     // obj_extendDefaults((options as TTransport.Options.Ws).clientConfig, {
+    //     //     // default frame size is too small
+    //     //     maxReceivedFrameSize: 50_000_000,
+    //     //     maxReceivedMessageSize: 50_000_000,
+    //     // });
+
+    //     let transport = new WsTransport({ url, ...options });
+
+    //     // transport.on('close', ev => this.websocket.code = ev.code);
+    //     // transport.on('connect', _ => this.websocket.code = WS_STATE.CONNECTED);
+
+    //     return transport;
+    // }
 
-    async send <TResult> (fn: (web3: Web3) => PromiEvent<TResult> ): Promise<{ status: ClientStatus, error?, result?: PromiEvent<TResult> }> {
+    async send<TResult>(fn: (web3: WClient) => PromiseEvent<TResult>): Promise<{ status: ClientStatus, error?, result?: PromiseEvent<TResult> }> {
         return new Promise((resolve, reject) => {
-            let result = fn(this.web3);
+            let result = fn(this);
 
             result.then(
                 _ => {
@@ -540,7 +838,7 @@ class WClient {
                     resolve({ status: ClientStatus.Ok, result })
                 },
                 error => {
-                    if (ClientErrorUtil.isConnectionFailed (error)) {
+                    if (ClientErrorUtil.isConnectionFailed(error)) {
                         this.lastStatus = ClientStatus.NetworkError;
                         this.requests.fail++;
                         resolve({ status: ClientStatus.NetworkError, error });
@@ -550,43 +848,117 @@ class WClient {
             );
         });
     }
+    sendSignedTransaction (tx: TEth.Hex) {
+        let promise = new PromiseEvent<TEth.TxReceipt>();
+        this
+            .rpc
+            .eth_sendRawTransaction(tx)
+            .then(async hash => {
+                promise.emit('transactionHash', hash);
+                let receipt = await $rpc.waitForReceipt(this.rpc, hash);
+                promise.resolve(receipt);
+            }, error => {
+                promise.reject(error);
+            });
+        return promise;
+    }
+    sendTransaction (tx) {
+        let promise = new PromiseEvent<TEth.TxReceipt>();
+        this
+            .rpc
+            .eth_sendTransaction(tx)
+            .then(async hash => {
+                promise.emit('transactionHash', hash);
+                let receipt = await $rpc.waitForReceipt(this.rpc, hash);
+                promise.resolve(receipt);
+            }, error => {
+                promise.reject(error);
+            });
+        return promise;
+    }
 
-    // async call <TResult> (fn: (web3: Web3) => Promise<TResult> ): Promise<{ status: number, result?: TResult }> {
-    //     try {
-    //         let result = await fn(this.web3);
-
-    //         this.lastStatus = Status.Ok;
-    //         this.requests.success++;
+    async callBatched<TResult = any>(requests: TRpc.IRpcAction[]): Promise<TResult[]> {
+        let total = requests.length;
+        let spanLimit = this.getSpanLimit(requests.length);
+        let output = [] as TResult[];
+        let errors = [];
+        let pageIdx = 0;
+        while (requests.length > 0) {
+            ++pageIdx;
+            let page = requests.splice(0, spanLimit);
+            if (requests.length > 0 || pageIdx > 1) {
+                $logger.throttled(`Sending ${page.length} batched requests. Loaded ${output.length}/${total}`);
+            }
+            let { status, error, result: pageResult } = await this.call(async (client) => {
+                let batch = new Web3BatchRequests.BatchRequest(client.rpc, page);
+                let results = await batch.execute();
+                return results;
+            });
+            if (status === ClientStatus.Ok) {
+                output.push(...pageResult);
+                continue;
+            }
+            if (status === ClientStatus.RateLimited) {
+                spanLimit = this.getSpanLimit(requests.length);
+            }
+            errors.push(error);
+            if (errors.length > 2) {
+                throw error;
+            }
+            requests.unshift(...page);
+        }
+        return output;
+    }
 
-    //         return { status: Status.Ok, result };
+    async call<TResult extends PromiseLike<any>>(fn: (wClient: WClient) => TResult, options?: {
+        // For the rate limit guard, to make sure we wait enough time to proceed with batch request for example
+        batchRequestCount?: number
+    }): Promise<{ status: ClientStatus, error?, result?: Awaited<TResult>, time: number }> {
+        let now = Date.now();
+        await this.rateLimitGuard?.wait(options?.batchRequestCount ?? 1, now);
+
+        let connectionError = await this.ensureConnected();
+        if (connectionError) {
+            return {
+                status: ClientStatus.NetworkError,
+                result: null,
+                error: connectionError,
+                time: Date.now() - now
+            };
+        }
 
-    //     } catch (error) {
-    //         console.log(error);
-    //         if (this.isConnectionFailed (error)) {
-    //             this.lastStatus = Status.NetworkError;
-    //             this.requests.fail++;
-    //             return { status: Status.NetworkError, result: error };
-    //         }
-    //         return { status: Status.CallError, result: error }
-    //     }
-    // }
-    async call <TResult extends PromiseLike<any>> (fn: (web3: Web3) => TResult ): Promise<{ status: ClientStatus, error?, result?: TResult, time: number }> {
         return new Promise((resolve, reject) => {
             let start = Date.now();
-            let result = fn(this.web3);
+            let result = fn(this);
 
             result.then(
-                _ => {
+                result => {
                     let time = Date.now() - start;
                     let status = ClientStatus.Ok;
                     this.onComplete(status, time);
+                    this.rateLimitGuard?.onComplete(now);
                     resolve({ status, result, time })
                 },
                 error => {
                     let time = Date.now() - start;
-                    let status =  ClientStatus.CallError;
+                    let status = ClientStatus.CallError;
+
+                    if (RateLimitGuard.isRateLimited(error)) {
+                        status = ClientStatus.RateLimited;
 
-                    if (ClientErrorUtil.isConnectionFailed (error)) {
+                        let rateLimitInfo = RateLimitGuard.extractRateLimitFromError(error);
+                        if (rateLimitInfo == null) {
+                            l`RateLimit not extracted: ${error.message}`;
+                        }
+                        this.updateRateLimitInfo(rateLimitInfo);
+                    } else if (RateLimitGuard.isBatchLimit(error)) {
+                        status = ClientStatus.RateLimited;
+                        let limit = RateLimitGuard.extractBatchLimitFromError(error);
+                        if (limit !== this.batchLimit) {
+                            l`yellow<New BatchLimit> for "${this.config.url}" bold<${limit}>`;
+                            this.batchLimit = limit;
+                        }
+                    } else if (ClientErrorUtil.isConnectionFailed(error)) {
                         status = ClientStatus.NetworkError;
                     }
                     this.onComplete(status, time);
@@ -596,10 +968,10 @@ class WClient {
         });
     }
 
-    callPromiEvent <TResult extends PromiEvent<any>> (fn: (web3: Web3) => TResult ): TResult {
-        let result = fn(this.web3);
+    callPromiEvent<TResult extends PromiseEvent<any>>(fn: (web3: WClient) => TResult): TResult {
+        let result = fn(this);
         result.on('error', error => {
-            if (ClientErrorUtil.isConnectionFailed (error)) {
+            if (ClientErrorUtil.isConnectionFailed(error)) {
                 this.lastStatus = ClientStatus.NetworkError;
                 this.requests.fail++;
             }
@@ -610,10 +982,10 @@ class WClient {
         })
         return result;
     }
-    callSubscription <TResult extends PromiEvent<any>> (fn: (web3: Web3) => TResult ): TResult {
-        let result = fn(this.web3);
+    callSubscription<TResult extends PromiseEvent<any>>(fn: (web3: WClient) => TResult): TResult {
+        let result = fn(this);
         result.on('error', error => {
-            if (ClientErrorUtil.isConnectionFailed (error)) {
+            if (ClientErrorUtil.isConnectionFailed(error)) {
                 this.lastStatus = ClientStatus.NetworkError;
                 this.requests.fail++;
             }
@@ -625,32 +997,18 @@ class WClient {
         return result;
     }
 
-    getEventStream (address: TAddress, abi: AbiItem[], event: string, options = {}): ClientEventsStream {
-        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 }`);
-        }
-        const contract = new this.eth.Contract(abi, address);
-        const stream =  contract
-            .events
-            [event](options);
-
-        const worker = new ClientEventsStream(contract, eventAbi, stream)
-        return worker;
-    }
 
-    callSync <TResult> (fn: (web3: Web3) => TResult ): { status: number, result?: TResult } {
-        try {
-            let result = fn(this.web3);
-            return { status: ClientStatus.Ok, result };
+    // callSync<TResult>(fn: (web3: Web3) => TResult): { status: number, result?: TResult } {
+    //     try {
+    //         let result = fn(this.web3);
+    //         return { status: ClientStatus.Ok, result };
 
-        } catch (error) {
-            return { status: ClientStatus.CallError, result: error }
-        }
-    }
+    //     } catch (error) {
+    //         return { status: ClientStatus.CallError, result: error }
+    //     }
+    // }
 
-    onComplete (status: ClientStatus, timeMs: number) {
+    onComplete(status: ClientStatus, timeMs: number) {
         let callCount = this.getRequestCount();
         let ping = this.requests.ping;
 
@@ -666,8 +1024,59 @@ class WClient {
         this.requests.ping = (ping * callCount + timeMs) / (callCount + 1);
     }
 
-    getRequestCount () {
+    async ensureConnected(): Promise<Error> {
+        // if (this.config.url?.startsWith('ws')) {
+        //     if (this.websocket.code === WS_STATE.ECONNRESET) {
+        //         // recreate connection when ERRCONNRESET was thrown previously
+        //         this.createWebSocketClient();
+        //     }
+
+        //     let web3 = this.web3;
+        //     let provider = web3.eth.currentProvider as WebsocketProvider & { url };
+        //     if (provider.connected === false) {
+        //         provider.connect();
+        //         try {
+        //             await $promise.waitForTrue(() => provider.connected, {
+        //                 intervalMs: 200,
+        //                 timeoutMessage: `Couldn't connect to WS ${provider.url}`,
+        //                 timeoutMs: 20_000
+        //             });
+        //             return null;
+        //         } catch (error) {
+        //             return error;
+        //         }
+        //     }
+        // }
+        return null;
+    }
+
+    getRequestCount() {
         return this.requests.success + this.requests.fail;
     }
 
+    /**
+     * Checks the rate limit wait time, so that the POOL can select the wClient with shortest wait time
+     **/
+    getRateLimitGuardTime() {
+        return this.rateLimitGuard?.checkWaitTime() ?? 0;
+    }
+
+    private getSpanLimit(requestCount: number) {
+        let a = this.rateLimitGuard?.getSpanLimit() ?? Infinity;
+        let b = this.batchLimit ?? Infinity;
+
+        let min = requestCount === 0
+            ? Math.min(a, b)
+            : Math.min(a, b, requestCount);
+        $require.gt(min, 0, `Span-limit must be > 0. ${a}/${b}/${requestCount}`);
+        return min;
+    }
 }
+
+
+
+const WS_STATE = {
+    NOTSET: 0,
+    CONNECTED: 1,
+    ECONNRESET: 1006
+};