dequanto 0.0.1 → 0.0.7

package/dist/src/clients/ClientPool.js

@@ -19,15 +19,23 @@ const PromiEventWrap_1 = require("./model/PromiEventWrap");
 const ClientStatus_1 = require("./model/ClientStatus");
 const ClientPoolStats_1 = require("./ClientPoolStats");
 const atma_utils_1 = require("atma-utils");
-const ClientEventsStream_1 = require("./ClientEventsStream");
 const ClientErrorUtil_1 = require("./utils/ClientErrorUtil");
-const _fn_1 = require("@dequanto/utils/$fn");
+const _logger_1 = require("@dequanto/utils/$logger");
+const _promise_1 = require("@dequanto/utils/$promise");
 class ClientPool {
     constructor(config) {
-        this.config = config;
         this.discoveredPartial = false;
         this.discoveredFull = false;
-        this.clients = this.config.map(cfg => new WClient(cfg));
+        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;
@@ -69,28 +77,38 @@ class ClientPool {
             }
             if (status === ClientStatus_1.ClientStatus.CallError) {
                 let error = ClientPoolStats_1.ClientPoolTraceError.create(errors.pop(), opts?.trace);
-                //console.log(`Errored ${error.message}`);
                 throw error;
                 return result;
             }
         }
     }
     async getWeb3(options) {
-        let wClient = await this.next(null, options);
+        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;
     }
     async getNodeURL(options) {
-        let wClient = await this.next(null, options);
+        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() {
     }
+    getOptionForFetchableRange() {
+        const DEFAULT = null;
+        let max = (0, alot_1.default)(this.clients).max(x => x.config?.fetchableBlockRange ?? 0);
+        if (max === 0) {
+            return DEFAULT;
+        }
+        return max;
+    }
     callPromiEvent(fn, opts, used = new Map(), errors = [], root) {
         root = root ?? new PromiEventWrap_1.PromiEventWrap();
         (async () => {
@@ -113,30 +131,21 @@ class ClientPool {
             let promiEvent = wClient.callPromiEvent(fn);
             root.bind(promiEvent);
             promiEvent.on('error', async (error) => {
-                console.log('!!client ERROR', error);
                 error.message += ` (RPC: ${wClient.config.url})`;
                 if (ClientErrorUtil_1.ClientErrorUtil.isConnectionFailed(error)) {
                     this.callPromiEvent(fn, opts, used, errors, root);
                     return;
                 }
                 if (ClientErrorUtil_1.ClientErrorUtil.isAlreadyKnown(error)) {
-                    console.log(`TxWriter ERROR ${error.message}. Check pending...`);
+                    _logger_1.$logger.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_1.$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);
             if (typeof opts?.parallel === 'number') {
                 while (--opts.parallel > 0) {
@@ -151,13 +160,13 @@ class ClientPool {
         })();
         return root;
     }
-    getEventStream(address, abi, event) {
-        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: AbiItem[], 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() {
         return this
             .clients
@@ -170,15 +179,24 @@ class ClientPool {
         });
     }
     async getNodeInfos() {
+        async function peerCount(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.eth.net.getPeerCount();
+            }
+            catch (error) {
+                return `ERROR: ${error.message}`;
+            }
+        }
         let nodes = await (0, alot_1.default)(this.clients).mapAsync(async (wClient, idx) => {
             let url = wClient.config.url;
             try {
                 let start = Date.now();
-                let [syncing, blockNumber, peers] = await Promise.all([
+                let [syncing, blockNumber, peers, node] = 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(),
+                    peerCount(wClient),
+                    wClient.eth.getNodeInfo(),
                 ]);
                 let ping = Math.round((Date.now() - start) / 3);
                 let syncData = typeof syncing === 'boolean' ? null : syncing;
@@ -190,6 +208,7 @@ class ClientPool {
                     blockNumberBehind: 0,
                     peers: peers,
                     pingMs: ping,
+                    node: node,
                     i: idx,
                 };
             }
@@ -242,16 +261,25 @@ class ClientPool {
     //     used.set(wClient, 1);
     //     return root as any as TResult;
     // }
-    async next(used, opts) {
+    async next(used, opts, params) {
+        let clients = this.clients;
+        if (params?.manual !== true) {
+            clients = clients.filter(x => x.config.manual !== true);
+        }
         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'));
+            clients = clients.filter(x => x.config.url?.startsWith('http'));
+        }
+        if (opts?.node?.traceable === true) {
+            clients = clients.filter(x => x.config.traceable === true);
         }
         if (this.discoveredPartial === false) {
             await this.discoverLive().ready;
@@ -323,7 +351,7 @@ class ClientPool {
                         error: null,
                         status: null,
                         blockNumberBehind: 0,
-                        blockNumber: await _fn_1.$fn.timeoutPromise(wClient.eth.getBlockNumber(), 20000)
+                        blockNumber: await _promise_1.$promise.timeout(wClient.eth.getBlockNumber(), 20000)
                     };
                     onIntermediateSuccess(clientInfo);
                     return clientInfo;
@@ -353,8 +381,8 @@ class ClientPool {
                 return;
             }
             const blockLatest = (0, alot_1.default)(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);
@@ -378,10 +406,11 @@ class ClientPool {
         function onIntermediateSuccess(info) {
             const TOLERATE_BLOCK_COUNT = 5;
             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;
             }
             let maxBlockNumber = (0, alot_1.default)(clientInfos).max(x => x.blockNumber);
@@ -394,7 +423,7 @@ 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();
@@ -408,8 +437,7 @@ __decorate([
 ], ClientPool.prototype, "discoverLive", null);
 exports.ClientPool = ClientPool;
 class WClient {
-    constructor(config) {
-        this.config = config;
+    constructor(mix) {
         this.lastStatus = 0;
         this.lastDate = new Date(2000);
         this.status = 'ok';
@@ -418,7 +446,25 @@ class WClient {
             fail: 0,
             ping: 0
         };
-        this.web3 = new web3_1.default(config.url);
+        const hasUrl = 'url' in mix && typeof mix.url === 'string';
+        const hasWeb3 = 'web3' in mix && typeof mix.web3 != null;
+        if (hasUrl || hasWeb3) {
+            this.config = mix;
+            if (mix.url) {
+                // web3 object
+                this.web3 = new web3_1.default(mix.url);
+            }
+            else if (mix.web3.eth != null) {
+                this.web3 = mix.web3;
+            }
+            else {
+                // provider
+                this.web3 = new web3_1.default(mix.web3);
+            }
+        }
+        else {
+            throw new Error(`Neither Node URL nor Web3 Instance in argument`);
+        }
         this.web3.eth.handleRevert = true;
         this.eth = this.web3.eth;
     }
@@ -519,18 +565,32 @@ class WClient {
         });
         return result;
     }
-    getEventStream(address, abi, event, options = {}) {
-        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_1.ClientEventsStream(contract, eventAbi, stream);
-        return worker;
-    }
+    // 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 }`);
+    //     }
+    //     let stream = new ClientEventsStream(this.address, this.abi)
+    //     this
+    //         .client
+    //         .subscribe('logs', {
+    //             address: this.address,
+    //             fromBlock: 'latest'
+    //         })
+    //         .then(subscription => {
+    //             stream.fromSubscription(subscription);
+    //         }, error => {
+    //             stream.error(error);
+    //         });
+    //     return stream;
+    //     // const contract = new this.eth.Contract(abi, address);
+    //     // const stream =  contract
+    //     //     .events
+    //     //     [event](options);
+    //     // const worker = new ClientEventsStream(address, eventAbi, stream)
+    //     // return worker;
+    // }
     callSync(fn) {
         try {
             let result = fn(this.web3);

package/dist/src/clients/EthWeb3Client.js

@@ -1,35 +1,20 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EthWeb3Client = void 0;
 const _config_1 = require("@dequanto/utils/$config");
-const tx_1 = require("@ethereumjs/tx");
-const common_1 = __importDefault(require("@ethereumjs/common"));
 const Web3Client_1 = require("./Web3Client");
 const ClientEndpoints_1 = require("./utils/ClientEndpoints");
 class EthWeb3Client extends Web3Client_1.Web3Client {
     constructor(opts) {
-        super(ClientEndpoints_1.ClientEndpoints.filterEndpoints(_config_1.$config.get('web3.eth.endpoints'), opts));
-        this.platform = 'eth';
-        this.chainId = 1;
-        this.chainToken = 'ETH';
+        super({
+            ...(opts ?? {}),
+            endpoints: ClientEndpoints_1.ClientEndpoints.filterEndpoints(opts?.endpoints ?? _config_1.$config.get(`web3.${opts?.platform ?? 'eth'}.endpoints`), opts)
+        });
+        this.platform = this.options.platform ?? 'eth';
+        this.chainId = this.options.chainId ?? 1;
+        this.chainToken = this.options.chainToken ?? 'ETH';
         this.TIMEOUT = 15 * 60 * 1000;
         this.defaultGasLimit = 2000000;
-        //let host = `192.168.1.220`;
-        // let host = `localhost`;
-        // this.web3 = new Web3(`ws://${host}:8546`);
-        // this.eth = this.web3.eth;
-    }
-    sign(txData, privateKey) {
-        const key = Buffer.from(privateKey, 'hex');
-        const common = new common_1.default({
-            chain: 'mainnet'
-        });
-        const tx = tx_1.Transaction.fromTxData(txData, { common });
-        const signedTx = tx.sign(key);
-        return signedTx.serialize();
     }
 }
 exports.EthWeb3Client = EthWeb3Client;

package/dist/src/clients/EvmWeb3Client.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvmWeb3Client = void 0;
+const Config_1 = require("@dequanto/Config");
+const _require_1 = require("@dequanto/utils/$require");
+const EthWeb3Client_1 = require("./EthWeb3Client");
+class EvmWeb3Client extends EthWeb3Client_1.EthWeb3Client {
+    constructor(options) {
+        super(resolveOptions(options));
+    }
+}
+exports.EvmWeb3Client = EvmWeb3Client;
+function resolveOptions(options) {
+    _require_1.$require.notNull(options?.platform, 'Platform is required when generic evm client is used');
+    let cfg = Config_1.config.web3[options.platform];
+    if (cfg) {
+        for (let key in cfg) {
+            if (options[key] == null) {
+                options[key] = cfg[key];
+            }
+        }
+    }
+    _require_1.$require.Numeric(options.chainId, `ChainID should be numeric. Got ${options.chainId}`);
+    return options;
+}

package/dist/src/clients/HardhatWeb3Client.js

@@ -1,56 +1,35 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HardhatWeb3Client = void 0;
-const common_1 = __importDefault(require("@ethereumjs/common"));
 const _config_1 = require("@dequanto/utils/$config");
 const Web3Client_1 = require("./Web3Client");
 const ClientEndpoints_1 = require("./utils/ClientEndpoints");
-const TxFactory_1 = require("./utils/TxFactory");
 // https://hardhat.org/hardhat-network/reference/
 class HardhatWeb3Client extends Web3Client_1.Web3Client {
     constructor(opts) {
-        super(ClientEndpoints_1.ClientEndpoints.filterEndpoints(_config_1.$config.get('web3.hardhat.endpoints'), opts));
+        super({
+            ...(opts ?? {}),
+            endpoints: ClientEndpoints_1.ClientEndpoints.filterEndpoints(_config_1.$config.get('web3.hardhat.endpoints'), opts),
+            debug: {
+                setStorageAt: {
+                    call: 'hardhat_setStorageAt',
+                    params: 3
+                },
+                setCode: {
+                    call: 'hardhat_setCode',
+                    params: 2,
+                },
+                setBalance: {
+                    call: 'hardhat_setBalance',
+                    params: 2
+                }
+            }
+        });
         this.platform = 'hardhat';
-        this.chainId = 31337;
+        this.chainId = this.options.chainId ?? 1337;
         this.chainToken = 'ETH';
         this.TIMEOUT = 5 * 60 * 1000;
         this.defaultGasLimit = 2000000;
     }
-    sign(txData, privateKey) {
-        const key = Buffer.from(privateKey, 'hex');
-        const common = new common_1.default({
-            chain: 31337,
-            hardfork: 'london',
-            customChains: [
-                {
-                    chainId: 31337,
-                    url: 'http://127.0.0.1:8545/',
-                    name: 'ETH',
-                    comment: '',
-                    hardforks: [
-                        {
-                            name: 'london',
-                            block: 0
-                        }
-                    ],
-                    genesis: {
-                        hash: '0x0000000000000000000000000000000000000000000000000000000000000000',
-                        timestamp: '0x5ED20F84',
-                        difficulty: 0x1,
-                        gasLimit: 0x989680,
-                        nonce: '0x0',
-                        stateRoot: '',
-                        extraData: '',
-                    }
-                }
-            ]
-        });
-        const tx = TxFactory_1.TxFactory.fromTxData(txData, { common });
-        const signedTx = tx.sign(key);
-        return signedTx.serialize();
-    }
 }
 exports.HardhatWeb3Client = HardhatWeb3Client;

package/dist/src/clients/PolyWeb3Client.js

@@ -1,20 +1,18 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PolyWeb3Client = void 0;
-const common_1 = __importDefault(require("@ethereumjs/common"));
 const _config_1 = require("@dequanto/utils/$config");
 const Web3Client_1 = require("./Web3Client");
 const ClientEndpoints_1 = require("./utils/ClientEndpoints");
 const _bigint_1 = require("@dequanto/utils/$bigint");
-const TxFactory_1 = require("./utils/TxFactory");
 class PolyWeb3Client extends Web3Client_1.Web3Client {
     constructor(opts) {
-        super(ClientEndpoints_1.ClientEndpoints.filterEndpoints(_config_1.$config.get('web3.polygon.endpoints'), opts));
+        super({
+            ...(opts ?? {}),
+            endpoints: ClientEndpoints_1.ClientEndpoints.filterEndpoints(_config_1.$config.get('web3.polygon.endpoints'), opts)
+        });
         this.platform = 'polygon';
-        this.chainId = 137;
+        this.chainId = this.options.chainId ?? 137;
         this.chainToken = 'MATIC';
         this.defaultGasLimit = 2000000;
     }
@@ -29,49 +27,5 @@ class PolyWeb3Client extends Web3Client_1.Web3Client {
             priority: gasPrice
         };
     }
-    // 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, privateKey) {
-        const key = Buffer.from(privateKey, 'hex');
-        const common = new common_1.default({
-            chain: 137,
-            hardfork: 'london',
-            customChains: [
-                {
-                    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_1.TxFactory.fromTxData(txData, { common });
-        const signedTx = tx.sign(key);
-        return signedTx.serialize();
-    }
 }
 exports.PolyWeb3Client = PolyWeb3Client;