dequanto 0.0.1 → 0.0.7

package/dist/src/gen/GeneratorStorageReader.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratorStorageReader = void 0;
+const alot_1 = __importDefault(require("alot"));
+const SlotsParser_1 = require("@dequanto/solidity/SlotsParser");
+const _require_1 = require("@dequanto/utils/$require");
+const atma_io_1 = require("atma-io");
+const Str_1 = require("./utils/Str");
+const _abiType_1 = require("@dequanto/utils/$abiType");
+const _path_1 = require("@dequanto/utils/$path");
+const _gen_1 = require("./utils/$gen");
+class GeneratorStorageReader {
+    async generate(opts) {
+        let { client, sources, contractName, address } = opts;
+        let files = alot_1.default.fromObject(sources ?? {}).map(x => {
+            return {
+                path: x.key,
+                content: x.value.content
+            };
+        }).toArray();
+        if (files.length === 0) {
+            return {};
+        }
+        let file = null;
+        if (files.length === 1) {
+            file = files[0];
+        }
+        else {
+            let rgx = new RegExp(`contract \s*${contractName}`, 'i');
+            let main = await (0, alot_1.default)(files.reverse()).findAsync(async (x) => {
+                return rgx.test(x.content);
+            });
+            if (main == null) {
+                main = files[0];
+            }
+            file = main;
+        }
+        _require_1.$require.String(file?.content ?? file?.path, `Expected a source content to resolve slots`);
+        let slots = await SlotsParser_1.SlotsParser.slots({ code: file.content, path: file.path }, contractName, { files });
+        let methods = this.serializeSlots(slots);
+        let codeMethods = methods.join('\n\n');
+        let templatePath = _path_1.$path.resolve(`/src/gen/ContractStorageReaderTemplate.ts`);
+        let template = await atma_io_1.File.readAsync(templatePath, { skipHooks: true });
+        let className = _gen_1.$gen.toClassName(opts.name + 'StorageReader');
+        let code = template
+            .replace(`$NAME$`, className)
+            .replace(`/* METHODS */`, codeMethods)
+            .replace(`$SLOTS$`, JSON.stringify(slots, null, '    '));
+        return {
+            className: className,
+            code: code
+        };
+    }
+    serializeSlots(slots) {
+        return slots
+            .map(slot => this.serializeSlot(slot))
+            .map(Str_1.Str.formatMethod);
+    }
+    serializeSlot(slot) {
+        let name = slot.name;
+        let type = slot.type;
+        let { parametersTypes, parametersCall, returnType } = this.getParameters(type);
+        return `
+            async ${name}(${parametersTypes ?? ''}): Promise<${returnType}> {
+                return this.$storage.get('${name}', ${parametersCall ?? ''});
+            }
+        `;
+    }
+    getParameters(type) {
+        if (type.startsWith('mapping')) {
+            let valueType = _abiType_1.$abiType.mapping.getValueType(type);
+            let keyType = _abiType_1.$abiType.mapping.getKeyType(type);
+            let keyTsType = _abiType_1.$abiType.getTsTypeFromDefinition(keyType);
+            let valueTsType = _abiType_1.$abiType.getTsTypeFromDefinition(valueType);
+            return {
+                parametersTypes: `key: ${keyTsType}`,
+                returnType: `${valueTsType}`,
+                parametersCall: 'key',
+            };
+        }
+        return {
+            returnType: _abiType_1.$abiType.getTsTypeFromDefinition(type)
+        };
+    }
+}
+exports.GeneratorStorageReader = GeneratorStorageReader;

package/dist/src/gen/utils/$gen.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$gen = void 0;
+var $gen;
+(function ($gen) {
+    function toClassName(name) {
+        let str = name.replace(/[^\w_\-\\/]/g, '');
+        str = str.replace(/[\-\\/](\w)/g, (full, letter) => {
+            return letter.toUpperCase();
+        });
+        return str[0].toUpperCase() + str.substring(1);
+    }
+    $gen.toClassName = toClassName;
+})($gen = exports.$gen || (exports.$gen = {}));

package/dist/src/gen/utils/Str.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Str = void 0;
+const alot_1 = __importDefault(require("alot"));
+var Str;
+(function (Str) {
+    function formatMethod(str) {
+        str = trim(str);
+        str = indent(str, '    ');
+        return str;
+    }
+    Str.formatMethod = formatMethod;
+    function trim(str) {
+        let lines = str.split('\n');
+        let min = (0, alot_1.default)(lines).min(line => {
+            if (line.trim() === '') {
+                return Number.MAX_SAFE_INTEGER;
+            }
+            let match = /^\s*/.exec(line);
+            if (match == null) {
+                return Number.MAX_SAFE_INTEGER;
+            }
+            return match[0].length;
+        });
+        lines = lines.map((line, i) => {
+            let x = line.substring(min);
+            if ((i === 0) || (lines.length === i + 1)) {
+                if (x === '') {
+                    return null;
+                }
+            }
+            return x;
+        }).filter(Boolean);
+        return lines.join('\n');
+    }
+    Str.trim = trim;
+    function indent(str, indent) {
+        return str
+            .split('\n')
+            .map(x => `${indent}${x}`)
+            .join('\n');
+    }
+    Str.indent = indent;
+})(Str = exports.Str || (exports.Str = {}));

package/dist/src/hardhat/HardhatProvider.js

@@ -0,0 +1,177 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HardhatProvider = void 0;
+const memd_1 = __importDefault(require("memd"));
+const HardhatWeb3Client_1 = require("@dequanto/clients/HardhatWeb3Client");
+const atma_utils_1 = require("atma-utils");
+const atma_io_1 = require("atma-io");
+const ethers_1 = require("ethers");
+const _logger_1 = require("@dequanto/utils/$logger");
+const _number_1 = require("@dequanto/utils/$number");
+class HardhatProvider {
+    constructor() {
+        /* lazy load */
+        this.hh = require('hardhat');
+        if (this.hh.ethers == null) {
+            throw new Error(`hardhat-ethers plugin should be installed and included in hardhat.config.js`);
+        }
+        if (this.hh.web3 == null) {
+            throw new Error(`hardhat-web3 plugin should be installed and included in hardhat.config.js`);
+        }
+    }
+    client(network = 'hardhat') {
+        if (network == 'localhost') {
+            return new HardhatWeb3Client_1.HardhatWeb3Client({
+                endpoints: [
+                    { url: 'http://127.0.0.1:8545' },
+                    // Use `manual`, will be used for subscriptions only, otherwise BatchRequests will fail, as not implemented yet
+                    // https://github.com/NomicFoundation/hardhat/issues/1324
+                    { url: 'ws://127.0.0.1:8545', manual: true },
+                ]
+            });
+        }
+        const web3 = this.hh.web3;
+        const client = new HardhatWeb3Client_1.HardhatWeb3Client({ web3 });
+        return client;
+    }
+    deployer(index = 0) {
+        const ethers = this.hh.ethers;
+        const accounts = this.hh.config.networks.hardhat.accounts;
+        const wallet = ethers.Wallet.fromMnemonic(accounts.mnemonic, accounts.path + `/${index}`);
+        return {
+            key: wallet.privateKey,
+            address: wallet.address,
+        };
+    }
+    async deployClass(Ctor, options) {
+        let ethers = this.hh.ethers;
+        let client = options?.client ?? this.client();
+        let signer = options?.deployer ?? this.deployer();
+        let params = options?.arguments ?? [];
+        let Factory = await this.getFactory([Ctor.name], client, signer);
+        const contract = await Factory.deploy(...params);
+        const receipt = await contract.deployed();
+        _logger_1.$logger.log(`Contract ${Ctor.name} deployed to ${contract.address}`);
+        return new Ctor(contract.address, client);
+    }
+    async deploySol(solContractPath, options) {
+        const client = options?.client ?? this.client();
+        const args = options?.arguments ?? [];
+        const signer = options?.deployer ?? this.deployer();
+        const dir = solContractPath.replace(/[^\/]+$/, '');
+        const filename = /(?<filename>[^\/]+)\.\w+$/.exec(solContractPath)?.groups.filename;
+        let root = options?.paths?.root;
+        let artifacts = options?.paths?.artifacts;
+        if (filename == null) {
+            throw new Error(`Filename not extracted from ${solContractPath}`);
+        }
+        let hhOptions = {
+            sources: dir,
+            root,
+            artifacts,
+            tsgen: false,
+        };
+        await this.hh.run('compile', hhOptions);
+        if (root == null) {
+            root = 'file://' + process.cwd();
+        }
+        if (artifacts == null && root != null) {
+            artifacts = atma_utils_1.class_Uri.combine(root, 'artifacts/');
+        }
+        if (root != null && solContractPath.toLowerCase().includes(root.toLowerCase())) {
+            let i = solContractPath.toLowerCase().indexOf(root.toLowerCase());
+            solContractPath = solContractPath.substring(i + root.length);
+        }
+        let outputDir = atma_utils_1.class_Uri.combine(artifacts, solContractPath);
+        let output = atma_utils_1.class_Uri.combine(outputDir, `${filename}.json`);
+        console.log(`Compiled OK Output ${output} outputDir ${outputDir}`);
+        if (await atma_io_1.File.existsAsync(output) === false) {
+            let path = `${outputDir}/`;
+            if (await atma_io_1.Directory.existsAsync(path) === false) {
+                throw new Error(`No JSONs found in ${outputDir}, nor ${output}`);
+            }
+            let files = await atma_io_1.Directory.readFilesAsync(path);
+            let jsons = files.filter(x => /(?<!dbg)\.json$/.test(x.uri.file));
+            if (jsons.length === 0) {
+                throw new Error(`No JSONs output found in ${outputDir}`);
+            }
+            if (jsons.length === 1) {
+                output = jsons[0].uri.toString();
+            }
+            else {
+                let jsonFile = jsons.find(file => {
+                    return filename.includes(file.uri.filename);
+                });
+                if (jsonFile == null) {
+                    throw new Error(`Compiled JSON data not found for ${filename} in ${outputDir}`);
+                }
+                output = jsonFile.uri.toString();
+            }
+        }
+        let { abi, bytecode } = await atma_io_1.File.readAsync(output);
+        let Factory = await this.getFactory([abi, bytecode], client, signer);
+        const contract = await Factory.deploy(...args);
+        const receipt = await contract.deployed();
+        return {
+            contract,
+            abi,
+            bytecode
+        };
+    }
+    async deployCode(solidityCode, options) {
+        let className = /contract\s+(?<name>[\w]+)/.exec(solidityCode).groups.name;
+        let rnd = _number_1.$number.randomInt(0, 10 ** 10);
+        let tmp = atma_io_1.env.getTmpPath(`hardhat/contracts/${className}_${rnd}.sol`);
+        let root = tmp.replace(/contracts\/[^/]+$/, '');
+        options.paths = {
+            root
+        };
+        await atma_io_1.File.writeAsync(tmp, solidityCode);
+        try {
+            return await this.deploySol(tmp, options);
+        }
+        finally {
+            await atma_io_1.Directory.removeAsync(root);
+        }
+    }
+    getEthersProvider(client) {
+        if (client.options.web3 != null) {
+            let ethers = this.hh.ethers;
+            return ethers.provider;
+        }
+        let url = client.options?.endpoints[0].url;
+        if (url.startsWith('ws')) {
+            return new ethers_1.ethers.providers.WebSocketProvider(url);
+        }
+        return new ethers_1.ethers.providers.JsonRpcProvider(url);
+    }
+    async getFactory(factoryArgs, client, signer) {
+        let ethers = this.hh.ethers;
+        let Factory = await ethers.getContractFactory(...factoryArgs);
+        let provider = this.getEthersProvider(client);
+        let $signer = 'key' in signer
+            ? new ethers.Wallet(signer.key, provider)
+            : signer;
+        Factory = Factory.connect($signer);
+        return Factory;
+    }
+}
+__decorate([
+    memd_1.default.deco.memoize()
+], HardhatProvider.prototype, "client", null);
+__decorate([
+    memd_1.default.deco.memoize()
+], HardhatProvider.prototype, "deployer", null);
+__decorate([
+    memd_1.default.deco.memoize()
+], HardhatProvider.prototype, "deployClass", null);
+exports.HardhatProvider = HardhatProvider;

package/dist/src/indexer/BlocksTxIndexer.js

@@ -9,16 +9,17 @@ class BlocksTxIndexer {
         this.platform = platform;
         this.opts = opts;
         this.listeners = [];
-        this.client = Web3ClientFactory_1.Web3ClientFactory.get(platform, {
+        this.client = this.opts.client ?? Web3ClientFactory_1.Web3ClientFactory.get(platform, {
             ws: true
         });
         this.walker = new BlocksWalker_1.BlocksWalker({
             name: `${opts?.name ?? 'indexer'}_${this.platform}`,
             client: this.client,
             loadTransactions: opts?.loadTransactions ?? true,
+            loadReceipts: opts?.loadReceipts ?? false,
             persistance: opts?.persistance ?? true,
-            visitor: async (block, txs) => {
-                return this.indexTransactions(block, txs);
+            visitor: async (block, data) => {
+                return this.indexTransactions(block, data);
             }
         });
     }
@@ -32,16 +33,27 @@ class BlocksTxIndexer {
     async start(from, to) {
         await this.walker.start(from, to);
         if (to == null) {
-            this.client.subscribe('newBlockHeaders', (error, blockHeader) => {
-                this.walker.processUntil(blockHeader.number);
+            await this.client.subscribe('newBlockHeaders', (error, blockHeader) => {
+                if (error) {
+                    _logger_1.$logger.error(`Subscription to "newBlockHeaders" failed with`, error);
+                    return;
+                }
+                if (blockHeader.transactions?.length === 0) {
+                    // hardhat emits empty blocks
+                    return;
+                }
+                this.walker.processUntil(blockHeader.number + 1);
             });
+            // Reload the blocknumber, to ensure we didn't missed the block between walker starting and subscription
+            let newTo = await this.client.getBlockNumber();
+            this.walker.processUntil(newTo + 1);
         }
     }
-    async indexTransactions(block, txs) {
+    async indexTransactions(block, data) {
         for (let i = 0; i < this.listeners.length; i++) {
             let indexer = this.listeners[i];
             try {
-                await indexer(this.client, block, txs);
+                await indexer(this.client, block, data);
             }
             catch (error) {
                 _logger_1.$logger.log(error);

package/dist/src/indexer/handlers/BlocksWalker.js

@@ -10,28 +10,32 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlocksWalker = void 0;
-const a_di_1 = __importDefault(require("a-di"));
 const alot_1 = __importDefault(require("alot"));
 const memd_1 = __importDefault(require("memd"));
-const _array_1 = require("@dequanto/utils/$array");
+const everlog_1 = require("everlog");
 const atma_io_1 = require("atma-io");
+const atma_utils_1 = require("atma-utils");
 const PackedRanges_1 = require("../../structs/PackedRanges");
-const everlog_1 = require("everlog");
-const BlockDateResolver_1 = require("@dequanto/blocks/BlockDateResolver");
+const _array_1 = require("@dequanto/utils/$array");
 const _date_1 = require("@dequanto/utils/$date");
-const atma_utils_1 = require("atma-utils");
-const _is_1 = require("@dequanto/utils/$is");
 const _logger_1 = require("@dequanto/utils/$logger");
+const _block_1 = require("@dequanto/utils/$block");
+const _require_1 = require("@dequanto/utils/$require");
 class BlocksWalker {
     constructor(params) {
         this.params = params;
+        this.onEndPromise = new atma_utils_1.class_Dfr;
         this.client = this.params.client;
         this.visitor = this.params.visitor;
         this.status = {
             blockLoadTime: 0
         };
-        this.cachedState = new atma_io_1.FileSafe(`./db/block-indexers/${this.params.name}.json`);
-        this.fs = everlog_1.Everlog.createChannel(`indexer-${this.params.name}`, {
+        this.cachedState = new atma_io_1.FileSafe(`./0xweb/block-indexers/${this.params.name}.json`, {
+            cached: false,
+            processSafe: true,
+            threadSafe: true
+        });
+        this.everlog = everlog_1.Everlog.createChannel(`indexer-${this.params.name}`, {
             fields: [
                 { name: 'Date', type: 'date' },
                 { name: 'Total', type: 'number' },
@@ -50,30 +54,28 @@ class BlocksWalker {
         if (this.isRestored === false) {
             await this.restore();
         }
-        let onlyIncoming = from == null && to == null;
-        if (onlyIncoming) {
-            return;
-        }
-        if (from == null) {
+        if (to != null && from == null) {
             throw new Error(`FromBlock should be set while ToBlock(${to}) is present`);
         }
         this.walker.setFrom(await this.getBlockNumber(from));
         this.walker.setTo(await this.getBlockNumber(to));
-        _is_1.$is.Number(this.ranges.from, 'From should be a number');
-        _is_1.$is.Number(this.ranges.to, 'To should be a number');
+        _require_1.$require.Number(this.ranges.from, 'From should be a number');
+        _require_1.$require.Number(this.ranges.to, 'To should be a number');
         this.walker.process();
-        _logger_1.$logger.log(`BlocksWalker starting. Processing: ${this.ranges.from}-${to}. Completed: ${this.ranges.totalAdded()}; ToDo: ${this.ranges.totalLeft()}`);
+        _logger_1.$logger.log(`BlocksWalker starting. Processing: ${this.ranges.from}-${to ?? 'latest'}. Completed: ${this.ranges.totalAdded()}; ToDo: ${this.ranges.totalLeft()}`);
     }
     /**
      *  Can be called each time we get a new block from blockchain,
      *  the walker will process its current blocks and up until the specified number
+     *  @param nr Number is not included: [from, end)
      */
     async processUntil(nr) {
         if (this.isRestored === false) {
             await this.restore();
         }
         this.walker.process(nr);
-        return this.onEndPromise = new atma_utils_1.class_Dfr;
+        this.onEndPromise.defer();
+        return this.onEndPromise;
     }
     stats() {
         return {
@@ -94,7 +96,7 @@ class BlocksWalker {
         catch (error) { }
         this.walker = new RangeWalker({
             range: this.ranges,
-            onVisit: (nr) => this.processBlock(nr),
+            onVisit: (nrs) => this.processBlocks(nrs),
             onResult: (error, nr) => {
                 this.save();
                 this.log();
@@ -130,28 +132,29 @@ class BlocksWalker {
         if (mix == null) {
             return this.client.getBlockNumber();
         }
-        if (typeof mix === 'number') {
-            return mix;
-        }
-        if (mix instanceof Date) {
-            let dateResolver = a_di_1.default.resolve(BlockDateResolver_1.BlockDateResolver, this.client);
-            return await dateResolver.getBlockNumberFor(mix);
-        }
-        throw new Error(`Invalid getBlockNumber param: ${mix}`);
+        return _block_1.$block.ensureNumber(mix, this.client);
     }
-    async processBlock(nr) {
+    async processBlocks(nrs) {
         // reading block and transactions
         let start = Date.now();
-        let block = await this.client.getBlock(nr);
-        let txs = null;
-        if (this.params.loadTransactions !== false) {
+        let blocks = await this.client.getBlocks(nrs);
+        let nr = await this.client.getBlockNumber();
+        let grouped = await (0, alot_1.default)(blocks).mapAsync(async (block) => {
             let hashes = block.transactions;
-            txs = await (0, alot_1.default)(hashes).mapAsync(async (hash) => {
-                return this.client.getTransaction(hash);
-            }).toArrayAsync({ threads: 8 });
-        }
-        this.status.blockLoadTime = Date.now() - start;
-        await this.visitor(block, txs);
+            let txs = this.params.loadTransactions
+                ? await this.client.getTransactions(hashes)
+                : null;
+            let receipts = this.params.loadReceipts
+                ? await this.client.getTransactionReceipts(hashes)
+                : null;
+            return { block, txs, receipts };
+        }).toArrayAsync({ threads: 4 });
+        this.status.blockLoadTime = (Date.now() - start) / nrs.length;
+        await (0, alot_1.default)(grouped)
+            .forEachAsync(async ({ block, txs, receipts }) => {
+            await this.visitor(block, { txs, receipts });
+        })
+            .toArrayAsync({ threads: 4 });
     }
     async save() {
         if (this.params.persistance !== false) {
@@ -171,12 +174,12 @@ class BlocksWalker {
             this.walker.status.errors,
             error,
         ];
-        this.fs.writeRow(row);
+        this.everlog.writeRow(row);
         _logger_1.$logger.log(row.join());
     }
 }
 __decorate([
-    memd_1.default.deco.memoize()
+    memd_1.default.deco.memoize({ perInstance: true })
 ], BlocksWalker.prototype, "restore", null);
 __decorate([
     memd_1.default.deco.throttle(1000 * 4)
@@ -189,6 +192,7 @@ class RangeWalker {
     constructor(params) {
         this.opts = {
             threads: 1,
+            batch: 1,
             timeout: 20000,
             // log every N ms
             logTimeWindow: 5000,
@@ -200,6 +204,7 @@ class RangeWalker {
         };
         this.busy = [];
         this.errors = [];
+        this.opts.batch = params.batch ?? this.opts.batch;
         this.range = params.range;
         this.onVisit = params.onVisit;
         this.onResult = params.onResult;
@@ -220,6 +225,7 @@ class RangeWalker {
         this.range.from = nr;
     }
     setTo(nr) {
+        nr += 1;
         let { from } = this.range;
         if (from != null && from > nr) {
             throw new Error(`To (${nr}) should be greater then From (${from})`);
@@ -263,44 +269,49 @@ class RangeWalker {
         if (this.busy.length > this.opts.threads) {
             return;
         }
-        let next = this.range.next();
-        if (next == null) {
+        let arr = [];
+        while (arr.length < this.opts.batch) {
+            let next = this.range.next();
+            if (next == null) {
+                break;
+            }
+            arr.push(next);
+        }
+        if (arr.length === 0) {
             this.onComplete?.();
             return null;
         }
-        let workerData = {
-            nr: next,
-            startedAt: Date.now()
-        };
+        let workersData = arr.map(nr => ({ nr, startedAt: Date.now() }));
         let error = null;
         try {
-            this.busy.push(workerData);
-            await this.onVisit(next);
+            this.busy.push(...workersData);
+            await this.onVisit(arr);
         }
         catch (err) {
             _logger_1.$logger.log('BlocksWalker.tick error', err);
             error = err;
         }
-        this.onResult?.(error, workerData.nr);
-        this.onTickComplete(workerData, error);
+        this.onResult?.(error, arr);
+        this.onTickComplete(workersData, error);
     }
-    onTickComplete(workerData, error) {
+    onTickComplete(workersData, error) {
+        let lastWorkerData = workersData[workersData.length - 1];
         if (error != null) {
             this.lastError = {
-                ...workerData,
-                duration: Date.now() - workerData.startedAt,
+                ...lastWorkerData,
+                duration: Date.now() - lastWorkerData.startedAt,
                 error
             };
             this.errors.push(this.lastError);
             this.status.errors += 1;
             _logger_1.$logger.log(error);
         }
-        let time = Date.now() - workerData.startedAt;
         let prevAvgTime = this.status.avgTime;
         let prevTotal = this.status.processed;
+        let time = (Date.now() - lastWorkerData.startedAt) / workersData.length;
         this.status.avgTime = Math.round((prevAvgTime * prevTotal + time) / (prevTotal + 1));
-        this.status.processed += 1;
-        _array_1.$array.remove(this.busy, workerData);
+        this.status.processed += workersData.length;
+        workersData.forEach(x => _array_1.$array.remove(this.busy, x));
         this.tick();
     }
 }

package/dist/src/loggers/LoggerService.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LoggerService = void 0;
+const _date_1 = require("@dequanto/utils/$date");
 const everlog_1 = require("everlog");
 class LoggerService {
     constructor(name = 'journal') {
@@ -15,19 +16,21 @@ class LoggerService {
         });
     }
     warn(message) {
-        this.write([new Date(), 'Warn', message]);
+        this.write(['Warn', message]);
     }
     error(message) {
-        this.write([new Date(), 'Error', message]);
+        this.write(['Error', message]);
     }
     info(message) {
-        this.write([new Date(), 'Info', message]);
+        this.write(['Info', message]);
     }
     write(row) {
         let arr = typeof row === 'string' ? [row] : row;
-        arr.unshift(new Date());
+        let date = new Date();
+        arr.unshift(date);
         this.channel.writeRow(arr);
-        console.log(Array.isArray(row) ? row.join(' ') : row);
+        arr[0] = _date_1.$date.format(date, 'HH:mm:ss');
+        console.log(arr.join(' '));
         return this;
     }
 }

package/dist/src/models/TAccount.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/ns/NameService.js

@@ -15,5 +15,8 @@ class NameService {
         _require_1.$require.notNull(provider, `NS Provider for ${domain} not found`);
         return provider.getAddress(domain);
     }
+    supports(mix) {
+        return this.providers.some(x => x.supports(mix));
+    }
 }
 exports.NameService = NameService;