dequanto 0.0.1 → 0.0.7

package/dist/src/clients/Web3Client.js

@@ -10,17 +10,64 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Web3Client = void 0;
+const a_di_1 = __importDefault(require("a-di"));
 const memd_1 = __importDefault(require("memd"));
+const ethers_1 = require("ethers");
 const ClientPool_1 = require("./ClientPool");
 const ClientPoolStats_1 = require("./ClientPoolStats");
+const BlockDateResolver_1 = require("@dequanto/blocks/BlockDateResolver");
+const _number_1 = require("@dequanto/utils/$number");
+const _txData_1 = require("@dequanto/utils/$txData");
+const _logger_1 = require("@dequanto/utils/$logger");
+const atma_utils_1 = require("atma-utils");
+const _promise_1 = require("@dequanto/utils/$promise");
+const ClientEventsStream_1 = require("./ClientEventsStream");
+const _abiUtils_1 = require("@dequanto/utils/$abiUtils");
+const ClientDebugMethods_1 = require("./debug/ClientDebugMethods");
 class Web3Client {
-    constructor(config) {
-        this.config = config;
+    constructor(mix) {
         this.TIMEOUT = 3 * 60 * 1000;
-        this.pool = new ClientPool_1.ClientPool(this.config);
+        this.defaultTxType = 2;
+        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_1.ClientPool(this.options);
+        this.debug = new ClientDebugMethods_1.ClientDebugMethods(this, this.options.debug);
+    }
+    async sign(txData, privateKey) {
+        let wallet = new ethers_1.Wallet(privateKey);
+        let json = _txData_1.$txData.getJson(txData, this);
+        let tx = await wallet.signTransaction(json);
+        return tx;
     }
     getEventStream(address, abi, event) {
-        return this.pool.getEventStream(address, abi, event);
+        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_1.ClientEventsStream(address, eventAbi);
+        this
+            .subscribe('logs', {
+            address: address,
+            fromBlock: 'latest',
+            topics: [
+                _abiUtils_1.$abiUtils.getMethodHash(eventAbi)
+            ]
+        })
+            .then(subscription => {
+            stream.fromSubscription(subscription);
+        }, error => {
+            stream.error(error);
+        });
+        return stream;
     }
     with(fn) {
         return this.pool.call(fn);
@@ -36,6 +83,15 @@ class Web3Client {
     }
     async subscribe(...args) {
         let web3 = await this.getWeb3({ ws: true });
+        let provider = web3.eth.currentProvider;
+        if (provider.connected === false) {
+            provider.connect();
+            await _promise_1.$promise.waitForTrue(() => provider.connected, {
+                intervalMs: 200,
+                timeoutMessage: `Can not connect to ${provider.url}`,
+                timeoutMs: 20000
+            });
+        }
         return web3.eth.subscribe(...args);
     }
     readContract(data) {
@@ -56,6 +112,16 @@ class Web3Client {
             trace: ClientPoolStats_1.ClientPoolTrace.createContractCall(address, method, params)
         });
     }
+    readContractBatch(requests) {
+        let trace = new ClientPoolStats_1.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, paramaters) {
         return this.pool.callSync(web3 => {
             return web3.eth.abi.encodeParameters(types, paramaters);
@@ -67,6 +133,14 @@ class Web3Client {
             return BigInt(weiStr);
         });
     }
+    getBalances(addresses, blockNumber) {
+        return this.pool.call(async (web3) => {
+            let reqs = addresses.map(address => cb => web3.eth.getBalance.request(address, blockNumber, cb));
+            let batch = new Web3BatchRequests.BatchRequest(web3, reqs);
+            let weiStrings = await batch.execute();
+            return weiStrings.map(weiStr => BigInt(weiStr));
+        });
+    }
     getTransactionCount(address, type) {
         return this.pool.call(web3 => {
             return web3.eth.getTransactionCount(address, type);
@@ -82,16 +156,64 @@ class Web3Client {
             return web3.eth.getTransaction(txHash);
         }, opts);
     }
+    getTransactions(hashes, opts) {
+        return this.pool.call(web3 => {
+            let reqs = hashes.map(hash => cb => web3.eth.getTransaction.request(hash, cb));
+            let batch = new Web3BatchRequests.BatchRequest(web3, reqs);
+            return batch.execute();
+        }, opts);
+    }
     getTransactionReceipt(txHash) {
         return this.pool.call(web3 => {
             return web3.eth.getTransactionReceipt(txHash);
         });
     }
+    getTransactionReceipts(hashes) {
+        return this.pool.call(web3 => {
+            let reqs = hashes.map(hash => cb => web3.eth.getTransactionReceipt.request(hash, cb));
+            let batch = new Web3BatchRequests.BatchRequest(web3, reqs);
+            return batch.execute();
+        });
+    }
+    getTransactionTrace(hash) {
+        return this.pool.call(async (web3) => {
+            let eth = web3.eth;
+            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) {
         return this.pool.call(web3 => {
             return web3.eth.getBlock(nr);
         });
     }
+    getBlocks(nrs) {
+        return this.pool.call(web3 => {
+            let reqs = nrs.map(nr => cb => web3.eth.getBlock.request(nr, cb));
+            let batch = new Web3BatchRequests.BatchRequest(web3, reqs);
+            return batch.execute();
+        });
+    }
+    getCode(address) {
+        return this.pool.call(web3 => {
+            return web3.eth.getCode(address);
+        });
+    }
     getPendingTransactions() {
         return this.pool.call(web3 => {
             return web3.eth.getPendingTransactions();
@@ -150,11 +272,34 @@ class Web3Client {
             return gasAmount;
         });
     }
+    async getAccounts(options) {
+        let web3 = await this.getWeb3(options);
+        return web3.eth.getAccounts();
+    }
+    async getChainId(options) {
+        let web3 = await this.getWeb3(options);
+        return web3.eth.getChainId();
+    }
+    async switchChain(params, options) {
+        let web3 = await this.getWeb3(options);
+        if (typeof web3.eth.currentProvider.request !== 'function') {
+            throw new Error(`Current provider doesn't have request method`);
+        }
+        return web3.eth.currentProvider.request({
+            method: 'wallet_switchEthereumChain',
+            params: [{ chainId: _number_1.$number.toHex(params.chainId) }],
+        });
+    }
     sendSignedTransaction(signedTxBuffer) {
         return this.pool.callPromiEvent(web3 => {
             return web3.eth.sendSignedTransaction(signedTxBuffer);
         }, { preferSafe: true, distinct: true });
     }
+    sendTransaction(data) {
+        return this.pool.callPromiEvent(web3 => {
+            return web3.eth.sendTransaction(data);
+        }, { preferSafe: true, distinct: true });
+    }
     getBlockNumber() {
         return this.pool.call(web3 => {
             return web3.eth.getBlockNumber();
@@ -165,22 +310,222 @@ class Web3Client {
             return web3.eth.getBlockNumber();
         });
     }
+    async getPastLogs(options) {
+        const getBlock = async (block, $default) => {
+            if (block == null) {
+                return $default;
+            }
+            if (block instanceof Date) {
+                let resolver = a_di_1.default.resolve(BlockDateResolver_1.BlockDateResolver, this);
+                return resolver.getBlockNumberFor(block);
+            }
+            return block;
+        };
+        const getBlockNumber = async (block) => {
+            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),
+            getBlockNumber(options.toBlock),
+        ]);
+        return await RangeWorker.fetchWithLimits(this, options, {
+            maxBlockRange: MAX,
+            maxResultCount: null,
+        }, {
+            fromBlock,
+            toBlock
+        });
+    }
     getNodeInfos() {
         return this.pool.getNodeInfos();
     }
     getNodeStats() {
         return this.pool.getNodeStats();
     }
-    static url(url) {
+    static url(mix, opts) {
         const Ctor = this;
-        return new Ctor({
-            endpoints: [
-                { url }
-            ],
-        });
+        let options;
+        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);
     }
 }
 __decorate([
     memd_1.default.deco.memoize({ maxAge: 30 })
 ], Web3Client.prototype, "getBlockNumberCached", null);
 exports.Web3Client = Web3Client;
+var Web3BatchRequests;
+(function (Web3BatchRequests) {
+    function contractRequest(web3, request, onComplete) {
+        let { contract, method, params, callArgs } = prepair(web3, request);
+        return contract.methods[method](...params).call.request(...callArgs, onComplete);
+    }
+    Web3BatchRequests.contractRequest = contractRequest;
+    function call(web3, request) {
+        let { contract, method, params, callArgs } = prepair(web3, request);
+        return contract.methods[method](...params).call(...callArgs);
+    }
+    Web3BatchRequests.call = call;
+    class BatchRequest {
+        //-private wasCompleted = false;
+        constructor(web3, requests) {
+            this.web3 = web3;
+            this.requests = requests;
+            this.promise = new atma_utils_1.class_Dfr();
+            this.results = new Array(this.requests.length);
+            this.awaitables = this.requests.length;
+        }
+        async execute() {
+            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;
+        }
+        onCompleted(i, error, result) {
+            this.results[i] = result ?? error;
+            if (--this.awaitables === 0) {
+                this.promise.resolve(this.results);
+            }
+        }
+    }
+    Web3BatchRequests.BatchRequest = BatchRequest;
+    function prepair(web3, request) {
+        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 };
+    }
+})(Web3BatchRequests || (Web3BatchRequests = {}));
+var RangeWorker;
+(function (RangeWorker) {
+    async function fetchWithLimits(client, options, limits, ranges) {
+        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;
+                complete = true;
+            }
+            _logger_1.$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;
+    }
+    RangeWorker.fetchWithLimits = fetchWithLimits;
+    ;
+    async function fetch(client, options, range, knownLimits) {
+        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_1.$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;
+        }
+    }
+})(RangeWorker || (RangeWorker = {}));

package/dist/src/clients/Web3ClientFactory.js

@@ -10,6 +10,9 @@ const EthWeb3Client_1 = require("./EthWeb3Client");
 const PolyWeb3Client_1 = require("./PolyWeb3Client");
 const ArbWeb3Client_1 = require("@dequanto/chains/arbitrum/ArbWeb3Client");
 const XDaiWeb3Client_1 = require("@dequanto/chains/xdai/XDaiWeb3Client");
+const HardhatProvider_1 = require("@dequanto/hardhat/HardhatProvider");
+const Config_1 = require("@dequanto/Config");
+const EvmWeb3Client_1 = require("./EvmWeb3Client");
 var Web3ClientFactory;
 (function (Web3ClientFactory) {
     function get(platform, opts) {
@@ -18,13 +21,25 @@ var Web3ClientFactory;
                 return a_di_1.default.resolve(BscWeb3Client_1.BscWeb3Client, opts);
             case 'eth':
                 return a_di_1.default.resolve(EthWeb3Client_1.EthWeb3Client, opts);
+            case 'eth:goerli':
+                return a_di_1.default.resolve(EthWeb3Client_1.EthWeb3Client, {
+                    platform: platform,
+                    chainId: 5,
+                    ...(opts ?? {})
+                });
             case 'polygon':
                 return a_di_1.default.resolve(PolyWeb3Client_1.PolyWeb3Client, opts);
             case 'arbitrum':
                 return a_di_1.default.resolve(ArbWeb3Client_1.ArbWeb3Client, opts);
             case 'xdai':
                 return a_di_1.default.resolve(XDaiWeb3Client_1.XDaiWeb3Client, opts);
+            case 'hardhat':
+                return a_di_1.default.resolve(HardhatProvider_1.HardhatProvider).client('localhost');
             default:
+                let cfg = Config_1.config.web3[platform];
+                if (cfg != null) {
+                    return new EvmWeb3Client_1.EvmWeb3Client({ platform, ...cfg });
+                }
                 throw new Error(`Unsupported platform ${platform} for web3 client`);
         }
     }

package/dist/src/clients/debug/ClientDebugMethods.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientDebugMethods = void 0;
+class ClientDebugMethods {
+    constructor(client, methods) {
+        this.client = client;
+        this.methods = methods;
+    }
+    getTransactionTrace(hash) {
+        return this.client.pool.call(async (web3) => {
+            let eth = web3.eth;
+            if (typeof eth.traceTransaction !== 'function') {
+                web3.eth.extend({
+                    methods: [
+                        {
+                            name: 'traceTransaction',
+                            call: 'debug_traceTransaction',
+                            params: 2,
+                        }
+                    ]
+                });
+            }
+            let result = await eth.traceTransaction(hash, {
+                tracer: 'callTracer'
+            });
+            return result;
+        }, {
+            node: {
+                traceable: true
+            }
+        });
+    }
+    setStorageAt(address, location, buffer) {
+        return this.call('setStorageAt', ...arguments);
+    }
+    setCode(address, buffer) {
+        return this.call('setCode', ...arguments);
+    }
+    setBalance(address, amount) {
+        return this.call('setBalance', ...arguments);
+    }
+    call(method, ...args) {
+        let meta = this.methods[method];
+        if (meta?.call == null) {
+            throw new Error(`RPC method for ${method} is not configurated in ${this.client.platform}`);
+        }
+        return this.client.pool.call(web3 => {
+            let eth = web3.eth;
+            if (eth[method] == null) {
+                web3.eth.extend({
+                    methods: [
+                        {
+                            name: method,
+                            call: meta.call,
+                            params: meta.params,
+                        }
+                    ]
+                });
+            }
+            return eth[method](...args);
+        });
+    }
+}
+exports.ClientDebugMethods = ClientDebugMethods;

package/dist/src/clients/utils/ClientEndpoints.js

@@ -4,12 +4,18 @@ exports.ClientEndpoints = void 0;
 var ClientEndpoints;
 (function (ClientEndpoints) {
     function filterEndpoints(endpoints, opts) {
+        if (opts?.web3) {
+            return [];
+        }
         if (opts?.endpoints) {
             endpoints = opts.endpoints;
         }
         if (opts == null) {
             return endpoints;
         }
+        if (endpoints == null) {
+            return null;
+        }
         return endpoints.filter(endpoint => {
             if (opts.type != null && endpoint.type !== opts.type) {
                 return false;

package/dist/src/clients/utils/TxFactory.js

@@ -1,14 +1,9 @@
 "use strict";
+// import {
+//     FeeMarketEIP1559Transaction,
+//     Transaction,
+//     TxData,
+//     FeeMarketEIP1559TxData,
+//     TxOptions
+// } from '@ethereumjs/tx';
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TxFactory = void 0;
-const tx_1 = require("@ethereumjs/tx");
-var TxFactory;
-(function (TxFactory) {
-    function fromTxData(txData, opts) {
-        const Factory = txData.type && Number(txData.type) === 2
-            ? tx_1.FeeMarketEIP1559Transaction
-            : tx_1.Transaction;
-        return Factory.fromTxData(txData, opts);
-    }
-    TxFactory.fromTxData = fromTxData;
-})(TxFactory = exports.TxFactory || (exports.TxFactory = {}));

package/dist/src/contracts/Contract.js

@@ -11,6 +11,7 @@ const ethers_1 = require("ethers");
 const TxDataBuilder_1 = require("@dequanto/txs/TxDataBuilder");
 const TxWriter_1 = require("@dequanto/txs/TxWriter");
 const _contract_1 = require("@dequanto/utils/$contract");
+const _is_1 = require("@dequanto/utils/$is");
 class Contract {
     constructor(data, opts) {
         this.name = null;
@@ -75,7 +76,7 @@ class Contract {
         let provider = a_di_1.default.resolve(ContractProvider_1.ContractProvider, opts.explorer);
         let info = await provider.getInfo(mix);
         if (info == null) {
-            let byName = mix.startsWith('0x') === false;
+            let byName = _is_1.$is.Address(mix) === false;
             if (byName) {
                 throw new Error(`Contract by name not found ${mix}`);
             }

package/dist/src/contracts/ContractAbiProvider.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractAbiProvider = void 0;
+const _address_1 = require("@dequanto/utils/$address");
+const _require_1 = require("@dequanto/utils/$require");
+const atma_io_1 = require("atma-io");
+const atma_utils_1 = require("atma-utils");
+const _path_1 = require("@dequanto/utils/$path");
+const _logger_1 = require("@dequanto/utils/$logger");
+class ContractAbiProvider {
+    constructor(client, explorer) {
+        this.client = client;
+        this.explorer = explorer;
+    }
+    async getAbi(abi, opts = null) {
+        _require_1.$require.notNull(abi, `Abi not provided to get the Abi Json from`);
+        let abiJson;
+        let implementation;
+        if (abi.startsWith('0x')) {
+            let { abi: abiResult, implementation: impl } = await this.getAbiByAddress(abi, opts);
+            abiJson = abiResult;
+            implementation = impl;
+        }
+        else {
+            let path = abi;
+            let location = opts?.location;
+            if (location && _path_1.$path.isAbsolute(path) === false) {
+                // if path not relative, check the file at ClassFile location
+                let relPath = atma_utils_1.class_Uri.combine(location, path);
+                if (await atma_io_1.File.existsAsync(relPath)) {
+                    path = relPath;
+                }
+            }
+            let json = await atma_io_1.File.readAsync(path);
+            abiJson = Array.isArray(json) ? json : json.abi;
+        }
+        _require_1.$require.notNull(abiJson, `Abi not resolved from ${abi}`);
+        return { abiJson, implementation };
+    }
+    async getAbiByAddress(abi, opts) {
+        let address = _address_1.$address.expectValid(abi, 'contract address is not valid');
+        let platform = this.client.platform;
+        let explorer = _require_1.$require.notNull(this.explorer, `Explorer not resolved for network: ${platform}`);
+        try {
+            _logger_1.$logger.log(`Loading contracts ABI for ${address}. `);
+            let { abi, implementation } = await explorer.getContractAbi(address, opts);
+            let hasProxy = _address_1.$address.eq(address, implementation) === false;
+            _logger_1.$logger.log(`Proxy detected: ${hasProxy ? 'YES' : 'NO'}`, hasProxy ? implementation : '');
+            let abiJson = JSON.parse(abi);
+            return { abi: abiJson, implementation };
+        }
+        catch (error) {
+            _logger_1.$logger.error(error);
+            throw new Error(`ABI is not resolved from ${platform}/${address}: ${error.message ?? error}`);
+        }
+    }
+}
+exports.ContractAbiProvider = ContractAbiProvider;