dequanto 0.0.1

package/dist/src/BlockchainExplorer/BlockChainExplorerFactory.js

@@ -0,0 +1,227 @@
+"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.BlockChainExplorerFactory = void 0;
+const alot_1 = __importDefault(require("alot"));
+const memd_1 = __importDefault(require("memd"));
+const axios_1 = __importDefault(require("axios"));
+const _logger_1 = require("@dequanto/utils/$logger");
+const _promise_1 = require("@dequanto/utils/$promise");
+var BlockChainExplorerFactory;
+(function (BlockChainExplorerFactory) {
+    function create(opts) {
+        const client = new Client();
+        return class {
+            constructor() {
+                this.localDb = opts.CONTRACTS;
+                this.config = opts.getConfig();
+                this.getContractAbi = memd_1.default.fn.memoize(this.getContractAbi, {
+                    trackRef: true,
+                    persistance: new memd_1.default.FsTransport({
+                        path: opts.ABI_CACHE
+                    })
+                });
+                this.getContractSource = memd_1.default.fn.memoize(this.getContractSource, {
+                    trackRef: true,
+                    persistance: new memd_1.default.FsTransport({
+                        path: opts.ABI_CACHE.replace('.json', '-source.json')
+                    })
+                });
+            }
+            async getContractMeta(q) {
+                q = q.toLowerCase();
+                let info = this.localDb.find(x => x.address.toLowerCase() === q || x.name?.toLowerCase() === q);
+                return info;
+            }
+            async getContractAbi(address, params) {
+                let info = await this.getContractMeta(address);
+                if (info?.proxy) {
+                    address = info.proxy;
+                }
+                let url = `${this.config.host}/api?module=contract&action=getabi&address=${address}&apikey=${this.config.key}`;
+                let abi = await client.get(url);
+                let abiJson = JSON.parse(abi);
+                if (params?.implementation) {
+                    if (/0x.{64}/.test(params.implementation)) {
+                        let web3 = opts.getWeb3();
+                        let stat = await web3.getNodeInfos();
+                        //-let x = (BigInt($contract.keccak256("eip1967.proxy.implementation")) - 1n).toString(16);
+                        let uin256Hex = await web3.getStorageAt('0x5a58505a96d1dbf8df91cb21b54419fc36e93fde', `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`);
+                        let hex = uin256Hex.replace(/0x0+/, '0x');
+                        return this.getContractAbi(hex);
+                    }
+                    throw new Error(`Implement ${params.implementation} support`);
+                }
+                if (isOpenZeppelinProxy(abiJson)) {
+                    let web3 = opts.getWeb3();
+                    let uin256Hex = await web3.getStorageAt(address, `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`);
+                    let hex = uin256Hex.replace(/0x0+/, '0x');
+                    return this.getContractAbi(hex);
+                }
+                if (hasImplementationSlot(abiJson)) {
+                    let web3 = opts.getWeb3();
+                    let uin256Hex = await web3.readContract({
+                        address: address,
+                        abi: abiJson,
+                        method: 'implementation',
+                        arguments: []
+                    });
+                    let hex = uin256Hex.replace(/0x0+/, '0x');
+                    return this.getContractAbi(hex);
+                }
+                if (hasTargetSlot(abiJson)) {
+                    let web3 = opts.getWeb3();
+                    let uin256Hex = await web3.readContract({
+                        address: address,
+                        abi: abiJson,
+                        method: 'getTarget',
+                        arguments: []
+                    });
+                    let hex = uin256Hex.replace(/0x0+/, '0x');
+                    return this.getContractAbi(hex);
+                }
+                return { abi, implementation: address };
+            }
+            async getContractSource(address) {
+                let url = `${this.config.host}/api?module=contract&action=getsourcecode&address=${address}&apikey=${this.config.key}`;
+                let result = await client.get(url);
+                return Array.isArray(result) ? result[0] : result;
+            }
+            async getTransactions(addr, params) {
+                return this.loadTxs('txlist', addr, params);
+            }
+            async getTransactionsAll(addr) {
+                return this.loadTxsAll('txlist', addr);
+            }
+            async getInternalTransactions(addr, params) {
+                return this.loadTxs('txlistinternal', addr, params);
+            }
+            async getInternalTransactionsAll(addr) {
+                return this.loadTxsAll('txlistinternal', addr);
+            }
+            async getErc20Transfers(addr, fromBlockNumber) {
+                let events = await this.loadTxs('tokentx', addr, { fromBlockNumber });
+                events.forEach(transfer => {
+                    transfer.timeStamp = new Date((Number(transfer.timeStamp) * 1000));
+                    transfer.value = BigInt(transfer.value);
+                    transfer.blockNumber = Number(transfer.blockNumber);
+                    transfer.tokenDecimal = Number(transfer.tokenDecimal);
+                });
+                return events;
+            }
+            async getErc20TransfersAll(addr, fromBlockNumber) {
+                let events = await this.loadTxsAll('tokentx', addr);
+                events.forEach(transfer => {
+                    transfer.timeStamp = new Date((Number(transfer.timeStamp) * 1000));
+                    transfer.value = BigInt(transfer.value);
+                    transfer.blockNumber = Number(transfer.blockNumber);
+                    transfer.tokenDecimal = Number(transfer.tokenDecimal);
+                });
+                return events;
+            }
+            async loadTxs(type, address, params) {
+                let url = `${this.config.host}/api?module=account&action=${type}&address=${address}&sort=${params.sort ?? 'desc'}&apikey=${this.config.key}`;
+                if (params.fromBlockNumber != null) {
+                    url += `&startblock=${params.fromBlockNumber}`;
+                }
+                if (params.page != null) {
+                    url += `&page=${params.page}`;
+                }
+                if (params.size != null) {
+                    url += `&offset=${params.size}`;
+                }
+                let txs = await client.get(url);
+                return txs;
+            }
+            async loadTxsAll(type, address) {
+                let page = 1;
+                let size = 1000;
+                let out = [];
+                let fromBlockNumber = null;
+                while (true) {
+                    let arr = await this.loadTxs(type, address, { fromBlockNumber, sort: 'asc' });
+                    out.push(...arr);
+                    _logger_1.$logger.log(`Got transactions(${type}) for ${address}. Page: ${arr.length}; Received: ${out.length}. Latest Block: ${fromBlockNumber}`);
+                    if (arr.length < size) {
+                        break;
+                    }
+                    page++;
+                    fromBlockNumber = Number(arr[arr.length - 1].blockNumber);
+                }
+                return (0, alot_1.default)(out).distinctBy(x => x.hash).toArray();
+            }
+        };
+    }
+    BlockChainExplorerFactory.create = create;
+})(BlockChainExplorerFactory = exports.BlockChainExplorerFactory || (exports.BlockChainExplorerFactory = {}));
+function isOpenZeppelinProxy(abi) {
+    let $interface = ['upgradeTo', 'implementation'];
+    return $interface.every(name => {
+        return abi.some(item => item.type === 'function' && item.name === name);
+    });
+}
+function hasImplementationSlot(abi) {
+    let $interface = ['proxyOwner', 'implementation'];
+    return $interface.every(name => {
+        return abi.some(item => item.type === 'function' && item.name === name);
+    });
+}
+function hasTargetSlot(abi) {
+    let $interface = ['upgrade', 'getTarget'];
+    return $interface.every(name => {
+        return abi.some(item => item.type === 'function' && item.name === name);
+    });
+}
+class Client {
+    async get(url) {
+        return this.getInner(url);
+    }
+    async getPaged(url) {
+        let arr = [];
+        let page = 1;
+        let size = 200;
+        while (true) {
+            let path = `${url}&page=${page}&offset=${size}`;
+            let pageArr = await this.get(path);
+            arr = arr.concat(pageArr);
+            if (pageArr.length < size) {
+                break;
+            }
+            page++;
+        }
+        return arr;
+    }
+    async getInner(url, opts) {
+        let resp = await axios_1.default.get(url);
+        let data = resp.data;
+        if (data.message === 'NOTOK') {
+            let str = data.result;
+            if (/Max rate/i.test(str)) {
+                let count = opts?.retryCount ?? 3;
+                if (--count === 0) {
+                    throw new Error(str);
+                }
+                await _promise_1.$promise.wait(200);
+                return this.getInner(url, {
+                    retryCount: count
+                });
+            }
+            throw new Error(str);
+        }
+        if (data.result == null) {
+            console.warn(`Blockchain "${url}" explorer returned empty result`, data);
+        }
+        return data.result;
+    }
+}
+__decorate([
+    memd_1.default.deco.queued({ throttle: 1000 / 5 })
+], Client.prototype, "get", null);

package/dist/src/BlockchainExplorer/BlockChainExplorerProvider.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockChainExplorerProvider = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const Arbiscan_1 = require("@dequanto/chains/arbitrum/Arbiscan");
+const Bscscan_1 = require("./Bscscan");
+const Etherscan_1 = require("./Etherscan");
+const Polyscan_1 = require("./Polyscan");
+const XDaiscan_1 = require("@dequanto/chains/xdai/XDaiscan");
+var BlockChainExplorerProvider;
+(function (BlockChainExplorerProvider) {
+    function get(platform) {
+        switch (platform) {
+            case 'bsc':
+                return a_di_1.default.resolve(Bscscan_1.Bscscan);
+            case 'eth':
+                return a_di_1.default.resolve(Etherscan_1.Etherscan);
+            case 'polygon':
+                return a_di_1.default.resolve(Polyscan_1.Polyscan);
+            case 'arbitrum':
+                return a_di_1.default.resolve(Arbiscan_1.Arbiscan);
+            case 'xdai':
+                return a_di_1.default.resolve(XDaiscan_1.XDaiscan);
+            default:
+                throw new Error(`Unsupported platform ${platform} for block chain explorer`);
+        }
+    }
+    BlockChainExplorerProvider.get = get;
+})(BlockChainExplorerProvider = exports.BlockChainExplorerProvider || (exports.BlockChainExplorerProvider = {}));

package/dist/src/BlockchainExplorer/BlockNumberCache.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockNumberCache = void 0;
+const Web3ClientFactory_1 = require("@dequanto/clients/Web3ClientFactory");
+const JsonArrayStore_1 = require("@dequanto/json/JsonArrayStore");
+class BlockNumberCache {
+    constructor(platform, name) {
+        this.platform = platform;
+        this.name = name;
+        this.store = new JsonArrayStore_1.JsonArrayStore({
+            path: `/cache/${platform}/blockNumber-${name}.json`,
+            key: x => x.address
+        });
+    }
+    async getCached(address) {
+        let entry = await this.store.getSingle(address);
+        return entry ?? {
+            address: address,
+            blockNumber: null,
+        };
+    }
+    async saveCached(cache) {
+        await this.store.upsert(cache);
+    }
+    async updateCache(cache) {
+        let client = Web3ClientFactory_1.Web3ClientFactory.get(this.platform);
+        let toleranz = 5;
+        let number = await client.getBlockNumberCached() - toleranz;
+        cache.blockNumber = Math.max(number, cache.blockNumber);
+        await this.store.upsert(cache);
+    }
+}
+exports.BlockNumberCache = BlockNumberCache;

package/dist/src/BlockchainExplorer/Bscscan.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bscscan = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const BlockChainExplorerFactory_1 = require("./BlockChainExplorerFactory");
+const _config_1 = require("@dequanto/utils/$config");
+const BscWeb3Client_1 = require("@dequanto/clients/BscWeb3Client");
+const contracts = _config_1.$config.get('contracts.bsc', []);
+class Bscscan extends BlockChainExplorerFactory_1.BlockChainExplorerFactory.create({
+    ABI_CACHE: `./cache/bsc/abis.json`,
+    CONTRACTS: contracts,
+    getWeb3() {
+        return a_di_1.default.resolve(BscWeb3Client_1.BscWeb3Client);
+    },
+    getConfig() {
+        const config = _config_1.$config.get('blockchainExplorer.bsc');
+        return {
+            key: config?.key,
+            host: config?.host,
+        };
+    }
+}) {
+}
+exports.Bscscan = Bscscan;

package/dist/src/BlockchainExplorer/Etherscan.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Etherscan = void 0;
+const BlockChainExplorerFactory_1 = require("./BlockChainExplorerFactory");
+const _config_1 = require("@dequanto/utils/$config");
+const EthWeb3Client_1 = require("@dequanto/clients/EthWeb3Client");
+const a_di_1 = __importDefault(require("a-di"));
+const contracts = _config_1.$config.get('contracts.eth', []);
+class Etherscan extends BlockChainExplorerFactory_1.BlockChainExplorerFactory.create({
+    ABI_CACHE: `./cache/eth/abis.json`,
+    CONTRACTS: contracts,
+    getWeb3() {
+        return a_di_1.default.resolve(EthWeb3Client_1.EthWeb3Client);
+    },
+    getConfig() {
+        const config = _config_1.$config.get('blockchainExplorer.eth');
+        return {
+            key: config?.key,
+            host: config?.host,
+        };
+    }
+}) {
+}
+exports.Etherscan = Etherscan;

package/dist/src/BlockchainExplorer/IAbiProvider.js

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

package/dist/src/BlockchainExplorer/IBlockChainExplorer.js

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

package/dist/src/BlockchainExplorer/Polyscan.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Polyscan = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const BlockChainExplorerFactory_1 = require("./BlockChainExplorerFactory");
+const _config_1 = require("@dequanto/utils/$config");
+const PolyWeb3Client_1 = require("@dequanto/clients/PolyWeb3Client");
+const contracts = _config_1.$config.get('contracts.polygon', []);
+class Polyscan extends BlockChainExplorerFactory_1.BlockChainExplorerFactory.create({
+    ABI_CACHE: `./cache/poly/abis.json`,
+    CONTRACTS: contracts,
+    getWeb3() {
+        return a_di_1.default.resolve(PolyWeb3Client_1.PolyWeb3Client);
+    },
+    getConfig() {
+        const config = _config_1.$config.get('blockchainExplorer.polygon');
+        return {
+            key: config?.key,
+            host: config?.host,
+        };
+    }
+}) {
+}
+exports.Polyscan = Polyscan;

package/dist/src/ChainAccounts.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainAccountProvider = exports.ChainAccount = void 0;
+const _config_1 = require("./utils/$config");
+const ethers_1 = require("ethers");
+const crypto_1 = __importDefault(require("crypto"));
+const _address_1 = require("./utils/$address");
+class ChainAccount {
+}
+exports.ChainAccount = ChainAccount;
+const accounts = _config_1.$config.get('accounts');
+var ChainAccountProvider;
+(function (ChainAccountProvider) {
+    function get(platform, name) {
+        let acc = accounts?.[platform]?.[name];
+        if (acc == null) {
+            throw new Error(`Account not resolved by name: ${name} in ${platform}`);
+        }
+        acc.name = name;
+        acc.platform = platform;
+        return acc;
+    }
+    ChainAccountProvider.get = get;
+    function tryGet(mix, platform) {
+        let all = this.getAll();
+        let accounts = all.filter(x => (_address_1.$address.eq(mix, x.address) || x.name == mix));
+        if (accounts.length === 0) {
+            return null;
+        }
+        let acc = accounts[0];
+        return {
+            ...acc,
+            platform: platform ?? acc.platform
+        };
+    }
+    ChainAccountProvider.tryGet = tryGet;
+    function getAll() {
+        let out = [];
+        for (let platform in accounts) {
+            for (let name in accounts[platform]) {
+                let account = accounts[platform][name];
+                account.name = name;
+                account.platform = platform;
+                out.push(account);
+            }
+        }
+        return out;
+    }
+    ChainAccountProvider.getAll = getAll;
+    function getAddressFromKey(key) {
+        const bytes = Buffer.from(key, 'hex');
+        const wallet = new ethers_1.Wallet(bytes);
+        return wallet.address;
+    }
+    ChainAccountProvider.getAddressFromKey = getAddressFromKey;
+    function generate(opts) {
+        const bytes = crypto_1.default.randomBytes(32);
+        const wallet = new ethers_1.Wallet(bytes);
+        return {
+            ...(opts ?? {}),
+            address: wallet.address,
+            key: bytes.toString('hex'),
+        };
+    }
+    ChainAccountProvider.generate = generate;
+})(ChainAccountProvider = exports.ChainAccountProvider || (exports.ChainAccountProvider = {}));

package/dist/src/ChainAccountsService.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainAccountsService = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const alot_1 = __importDefault(require("alot"));
+const ChainAccounts_1 = require("./ChainAccounts");
+const JsonArrayStore_1 = require("./json/JsonArrayStore");
+const _address_1 = require("./utils/$address");
+class ChainAccountsService {
+    constructor() {
+        this.store = a_di_1.default.resolve(Store);
+        this.config = ChainAccounts_1.ChainAccountProvider;
+    }
+    async get(mix, platform) {
+        let acc = this.config.tryGet(mix, platform);
+        return acc ?? this.store.get(mix);
+    }
+    async getAll() {
+        return this.store.getAll();
+    }
+    async generate(opts) {
+        let current = await this.get(opts.name, opts.platform);
+        if (current) {
+            return current;
+        }
+        let account = this.config.generate(opts);
+        await this.store.save(account);
+        return account;
+    }
+    async generateMany(names, platform) {
+        let newAccounts = [];
+        let accounts = await (0, alot_1.default)(names).mapAsync(async (name) => {
+            let current = await this.get(name, platform);
+            if (current) {
+                return current;
+            }
+            let account = this.config.generate({ name, platform });
+            newAccounts.push(account);
+            return account;
+        }).toArrayAsync();
+        if (newAccounts.length > 0) {
+            await this.store.saveMany(newAccounts);
+        }
+        return accounts;
+    }
+}
+exports.ChainAccountsService = ChainAccountsService;
+class Store {
+    constructor() {
+        this.fs = new JsonArrayStore_1.JsonArrayStore({
+            path: './db/accounts/accounts.json',
+            key: x => (x.key ?? x.address),
+            format: true,
+        });
+    }
+    async get(mix) {
+        let accounts = await this.fs.getAll();
+        if (_address_1.$address.isValid(mix)) {
+            return accounts.find(x => _address_1.$address.eq(mix, x.address));
+        }
+        return accounts.find(x => x.name === mix);
+    }
+    async getAll() {
+        return await this.fs.getAll();
+    }
+    async save(account) {
+        await this.fs.upsert(account);
+    }
+    async saveMany(accounts) {
+        await this.fs.upsertMany(accounts);
+    }
+}

package/dist/src/Config.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = exports.Config = void 0;
+class Config {
+}
+exports.Config = Config;
+exports.config = new Config();

package/dist/src/blocks/BlockDateResolver.js

@@ -0,0 +1,125 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockDateResolver = void 0;
+const _block_1 = require("@dequanto/utils/$block");
+const alot_1 = __importDefault(require("alot"));
+class BlockDateResolver {
+    constructor(client) {
+        this.client = client;
+        this.AVG_INITIAL = {
+            eth: 12 * 1000,
+            bsc: 3 * 1000,
+            polygon: 3 * 1000,
+        };
+        this.known = [];
+    }
+    async getBlockNumberFor(date) {
+        this.q = date;
+        let avg = this.AVG_INITIAL[this.client.platform];
+        if (avg == null) {
+            throw new Error(`AVG Block Time not defined for ${this.client.platform}`);
+        }
+        let now = new Date();
+        let topBlock = {
+            blockNumber: await this.client.getBlockNumberCached(),
+            date: now,
+            avg,
+        };
+        this.known.push(topBlock);
+        return await this.moveNext(date);
+    }
+    async moveNext(date) {
+        let closestIndex = this.getClosest(date);
+        let block = this.known[closestIndex];
+        let timeDiff = this.diffTime(block.date, date);
+        let timeDistance = Math.abs(timeDiff);
+        const BLOCKS_TOLERANCE = 2;
+        if (timeDistance <= block.avg * BLOCKS_TOLERANCE) {
+            return block.blockNumber;
+        }
+        if (this.closestTime != null && timeDistance >= this.closestTime) {
+            let b = this.known[this.closestIdx];
+            return b.blockNumber;
+        }
+        this.closestTime = timeDistance;
+        this.closestIdx = closestIndex;
+        let nextInfo = await this.checkPoint(block, timeDiff);
+        if (nextInfo == null) {
+            return block.blockNumber;
+        }
+        return this.moveNext(date);
+    }
+    /**
+     * Returns index of the first known block, which is most near to specified block (it can be before or after the specified date).
+     */
+    getClosest(date) {
+        let entry = (0, alot_1.default)(this.known).map(x => [
+            this.diffTimeAbs(x.date, date),
+            x
+        ]).minItem(x => x[0])[1];
+        let i = this.known.indexOf(entry);
+        return i;
+    }
+    async checkPoint(anchor, diffTime) {
+        let diffCount = Math.round(diffTime / anchor.avg);
+        if (diffCount === 0) {
+            return null;
+        }
+        let blockNumber = anchor.blockNumber + diffCount;
+        let date = await this.getBlockDate(blockNumber);
+        let info = {
+            blockNumber: blockNumber,
+            date: date,
+        };
+        this.push(info);
+        this.refineAvg();
+        return info;
+    }
+    push(info) {
+        for (let i = 0; i < this.known.length; i++) {
+            let x = this.known[i];
+            if (info.date < x.date) {
+                this.known.splice(i, 0, info);
+                return;
+            }
+        }
+        this.known.push(info);
+    }
+    /** Loads the block and gets the Date of the block */
+    async getBlockDate(blockNumber) {
+        let block = await this.client.getBlock(blockNumber);
+        if (block == null) {
+            throw new Error(`Block not loaded: ${blockNumber}`);
+        }
+        let date = _block_1.$block.getDate(block);
+        return date;
+    }
+    /** Returns SIGNED time in milliseconds between two dates. Negative values when t2 < t1 */
+    diffTime(t1, t2) {
+        return (t2.getTime() - t1.getTime());
+    }
+    /** Returns ABSOLUTE time in milliseconds between two dates.  */
+    diffTimeAbs(t1, t2) {
+        return Math.abs(this.diffTime(t1, t2));
+    }
+    /** Returns AVG block count between two dates */
+    getAvgBlockCountBetween(b1, b2) {
+        let diff = this.diffTimeAbs(b1.date, b2.date);
+        return Math.round(diff / Math.abs(b2.blockNumber - b1.blockNumber));
+    }
+    /** Having N>1 blocks we can better find out the AVG block time */
+    refineAvg() {
+        for (let i = 1; i < this.known.length; i++) {
+            let info = this.known[i];
+            let prev = this.known[i - 1];
+            info.avg = this.getAvgBlockCountBetween(prev, info);
+            if (i === 1) {
+                this.known[0].avg = info.avg;
+            }
+        }
+    }
+}
+exports.BlockDateResolver = BlockDateResolver;