dequanto 0.0.1

package/dist/src/txs/conditional/GasWatcherLogger.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GasWatcherLogger = void 0;
+const _bigint_1 = require("@dequanto/utils/$bigint");
+const _date_1 = require("@dequanto/utils/$date");
+const _logger_1 = require("@dequanto/utils/$logger");
+const everlog_1 = require("everlog");
+class GasWatcherLogger {
+    constructor() {
+        this.channels = {
+            prices: everlog_1.Everlog.createChannel('gaswatcher-prices', {
+                columns: [
+                    {
+                        type: 'date',
+                        name: 'Date'
+                    },
+                    {
+                        type: 'number',
+                        name: 'Price(Gwei)'
+                    },
+                ]
+            }),
+            txs: everlog_1.Everlog.createChannel('gaswatcher-txs', {
+                columns: [
+                    {
+                        type: 'date',
+                        name: 'Date'
+                    },
+                    {
+                        type: 'string',
+                        name: 'ID'
+                    },
+                    {
+                        type: 'string',
+                        name: 'Message'
+                    }
+                ]
+            }),
+        };
+    }
+    logPrice(gasPrice, block) {
+        let date = new Date();
+        let gwei = _bigint_1.$bigint.toGweiFromWei(gasPrice);
+        _logger_1.$logger.log(`Gas ${block || ''} ${_date_1.$date.format(date, 'HH:mm')} ${gwei} GWEI`);
+        this.channels.prices.writeRow([
+            date,
+            gwei,
+        ]);
+    }
+    logTx(id, message) {
+        let date = new Date();
+        let str = `Tx ${_date_1.$date.format(date, 'HH:mm')} ${message}`;
+        _logger_1.$logger.log(str);
+        this.channels.txs.writeRow([
+            date,
+            id,
+            str
+        ]);
+    }
+}
+exports.GasWatcherLogger = GasWatcherLogger;

package/dist/src/txs/conditional/GasWatcherService.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GasWatcherService = void 0;
+const _bigint_1 = require("@dequanto/utils/$bigint");
+const alot_1 = __importDefault(require("alot"));
+const GasWatcherLogger_1 = require("./GasWatcherLogger");
+const GasWatcherStore_1 = require("./GasWatcherStore");
+const GasWatcherTx_1 = require("./GasWatcherTx");
+class GasWatcherService {
+    constructor(client, store) {
+        this.client = client;
+        this.store = store;
+        this.pending = [];
+        this.logger = new GasWatcherLogger_1.GasWatcherLogger();
+    }
+    static async load(client, store = new GasWatcherStore_1.GasWatcherStore(client.platform)) {
+        let service = new GasWatcherService(client, store);
+        await service.loadTxs();
+        return service;
+    }
+    start() {
+        this.tick();
+        //setInterval(() => this.tick(), ms);
+    }
+    async tick() {
+        let start = Date.now();
+        let [block, priceInfo] = await Promise.all([
+            this.client.getBlockNumber(),
+            this.client.getGasPrice()
+        ]);
+        let price = priceInfo.price;
+        this.logger.logPrice(price, block);
+        await this.store.savePrice({ date: new Date(), price });
+        await (0, alot_1.default)(this.pending)
+            .forEachAsync(async (entry) => {
+            await entry.tick(price);
+        })
+            .toArrayAsync();
+        // let end = Date.now();
+        // console.log(`Gas tick completed in ${$date.formatTimespan(end - start)}`);
+        let ms = 30000;
+        if (this.pending.length > 0) {
+            let expectPrice = (0, alot_1.default)(this.pending).max(x => x.condition.price);
+            if (expectPrice < price && price - expectPrice < 10) {
+                ms = 15000;
+            }
+        }
+        // if (expectPrice < price) {
+        //     ms *= Number(price) / Number(expectPrice) * .5;
+        // }
+        setTimeout(() => {
+            this.tick();
+        }, ms);
+    }
+    async add(writer, condition) {
+        let writerJson = writer.toJSON();
+        let exists = this.pending.some(pending => {
+            let currentData = writer.builder.data;
+            let pendingData = pending.txWriter.builder.data;
+            let currentTo = currentData.to;
+            let pendingTo = pendingData.to;
+            if (currentTo !== pendingTo) {
+                return false;
+            }
+            let currentFrom = writer.account.address;
+            let pendingFrom = pending.txWriter.account.address;
+            if (currentFrom !== pendingFrom) {
+                return false;
+            }
+            if (currentData.data !== pendingData.data) {
+                return false;
+            }
+            // similar
+            return true;
+        });
+        if (exists) {
+            return;
+        }
+        let gasWatcherWriter = await GasWatcherTx_1.GasWatcherTx.fromJSON(condition, writerJson, this.logger);
+        this.pending.push(gasWatcherWriter);
+        let id = gasWatcherWriter.txWriter.id;
+        let gwei = _bigint_1.$bigint.toGweiFromWei(gasWatcherWriter.condition.price);
+        this.logger.logTx(id, `Transaction was added to listed for ${gwei} gas gwei`);
+        // Ensure completed txs are removed
+        this.pending = this.pending.filter(x => x.txWriter.receipt == null);
+        await this.saveTxs();
+    }
+    async loadTxs() {
+        let jsons = await this.store.loadTxs();
+        let pending = await (0, alot_1.default)(jsons)
+            .mapAsync(x => GasWatcherTx_1.GasWatcherTx.fromJSON(x.condition, x.writer, this.logger))
+            .toArrayAsync();
+        this.pending = pending;
+    }
+    async saveTxs() {
+        let jsons = this.pending.map(x => x.toJSON());
+        await this.store.saveTxs(jsons);
+    }
+}
+exports.GasWatcherService = GasWatcherService;

package/dist/src/txs/conditional/GasWatcherStore.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GasWatcherStore = void 0;
+const JsonObjectStore_1 = require("@dequanto/json/JsonObjectStore");
+class GasWatcherStore {
+    constructor(name = '') {
+        this.name = name;
+        this.jsonStore = new JsonObjectStore_1.JsonObjectStore({
+            path: `./db/gaswatcher/txs${this.name}.json`,
+            format: true,
+        });
+    }
+    async savePrice(enty) {
+    }
+    async loadPrices(from, toDate) {
+        return [];
+    }
+    async saveTxs(txs) {
+        return this.jsonStore.save(txs);
+    }
+    async loadTxs() {
+        return this.jsonStore.get();
+    }
+}
+exports.GasWatcherStore = GasWatcherStore;

package/dist/src/txs/conditional/GasWatcherTx.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GasWatcherTx = void 0;
+const _bigint_1 = require("@dequanto/utils/$bigint");
+const _logger_1 = require("@dequanto/utils/$logger");
+const TxWriter_1 = require("../TxWriter");
+class GasWatcherTx {
+    constructor(condition, txWriter, logger) {
+        this.condition = condition;
+        this.txWriter = txWriter;
+        this.logger = logger;
+        txWriter.on('log', message => this.log(message));
+    }
+    static async fromJSON(conditionJson, writerJson, logger) {
+        let writer = await TxWriter_1.TxWriter.fromJSON(writerJson);
+        return new GasWatcherTx({
+            price: BigInt(conditionJson.price)
+        }, writer, logger);
+    }
+    toJSON() {
+        return {
+            condition: this.condition,
+            writer: this.txWriter.toJSON(),
+        };
+    }
+    async tick(gasPrice) {
+        if (gasPrice > this.condition.price) {
+            // condition not matched
+            return;
+        }
+        if (this.txWriter.receipt != null) {
+            this.log(`Tx was already mined: ${this.txWriter.receipt.transactionHash}`);
+            return;
+        }
+        let tx = this.txWriter.tx;
+        if (tx == null) {
+            this.send(gasPrice);
+            return;
+        }
+        let timeEllipsedS = (Date.now() - tx.timestamp) / 1000 | 0;
+        if (tx.hash == null) {
+            if (timeEllipsedS > 30) {
+                // tx was not accepted for 30s
+                this.log(`Tx was not accepted for 30s. Resend`);
+                this.send(gasPrice);
+            }
+            // otherwise let wait for a hash
+            return;
+        }
+        let hash = tx.hash;
+        let client = this.txWriter.client;
+        let txData = await client.getTransaction(hash);
+        if (this.txWriter.receipt) {
+            // was mined inbetween
+            return;
+        }
+        if (txData == null) {
+            if (timeEllipsedS > 45) {
+                this.log(`Tx not in a pending block: ${hash}. Resend`);
+                // tx not in a pending block
+                this.send(gasPrice);
+            }
+            // otherwise let wait to be included into the pending block
+            return;
+        }
+        if (timeEllipsedS > 60 * 5) {
+            this.log(`Tx 5mins not mined: ${hash}. Resend`);
+            // 5mins not mined;
+            this.send(gasPrice);
+        }
+    }
+    async send(gasPrice) {
+        let writer = this.txWriter;
+        let builder = writer.builder;
+        let data = builder.data;
+        if (data.nonce == null) {
+            throw new Error(`Nonce should be already set on initial tx creating`);
+            await builder.setNonce();
+        }
+        if (writer.tx && data.gasPrice) {
+            // re-submitting
+            let currentGas = BigInt(data.gasPrice.toString());
+            if (currentGas >= gasPrice) {
+                // we can't resubmit with less gas
+                gasPrice = currentGas + _bigint_1.$bigint.toWeiFromGwei(.1);
+            }
+        }
+        await builder.setGas({
+            price: gasPrice,
+            priceRatio: 1,
+            gasLimit: data.gasLimit,
+        });
+        writer.tx = null;
+        writer.on('transactionHash', hash => {
+            let pendingCount = 0;
+            let nullCount = 0;
+            let interval = setInterval(async () => {
+                let tx = await writer.client.getTransaction(hash);
+                _logger_1.$logger.log('Check', hash, 'Block', tx?.blockNumber);
+                if (tx == null) {
+                    if (++nullCount > 8) {
+                        clearInterval(interval);
+                    }
+                    return;
+                }
+                if (tx.blockNumber) {
+                    // was mined;
+                    _logger_1.$logger.log(`${hash} Mined`);
+                    clearInterval(interval);
+                    return;
+                }
+                if (++pendingCount > 15) {
+                    clearInterval(interval);
+                    return;
+                }
+            }, 5000);
+        });
+        writer.send({
+            timeout: false
+        });
+    }
+    log(message) {
+        this.logger.logTx(this.txWriter.id, message);
+    }
+}
+exports.GasWatcherTx = GasWatcherTx;

package/dist/src/txs/receipt/ITxLogItem.js

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

package/dist/src/txs/receipt/TxLogParser.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.TxLogParser = void 0;
+const alot_1 = __importDefault(require("alot"));
+const _contract_1 = require("@dequanto/utils/$contract");
+const TxTopicProvider_1 = require("./TxTopicProvider");
+class TxLogParser {
+    constructor(topics = new TxTopicProvider_1.TxTopicProvider()) {
+        this.topics = topics;
+    }
+    async parse(receipt) {
+        let logs = await (0, alot_1.default)(receipt.logs).mapAsync(async (log) => {
+            let topic = await this.topics.get(log.topics[0]);
+            if (topic == null) {
+                return null;
+            }
+            let { abi, formatter } = topic;
+            let parsed = _contract_1.$contract.parseLogWithAbi(log, abi);
+            return parsed;
+        }).toArrayAsync();
+        return logs;
+    }
+}
+exports.TxLogParser = TxLogParser;

package/dist/src/txs/receipt/TxLogsTransfer.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxLogsTransfer = void 0;
+const alot_1 = __importDefault(require("alot"));
+const TokensServiceFactory_1 = require("@dequanto/tokens/TokensServiceFactory");
+const TxLogParser_1 = require("./TxLogParser");
+class TxLogsTransfer {
+    async extractFromWriter(writer) {
+        let receipt = await writer.onCompleted;
+        let knownLogs = writer.tx?.knownLogs ?? [];
+        return this.extractFromParsed(knownLogs, writer.client.platform);
+    }
+    async extractFromParsed(knownLogs, platform) {
+        let transfers = knownLogs.filter(x => x.name === 'Transfer');
+        let tokenService = TokensServiceFactory_1.TokensServiceFactory.get(platform);
+        return (0, alot_1.default)(transfers).mapAsync(async (transfer) => {
+            let erc20Address = transfer.contract;
+            let token = await tokenService.getTokenOrDefault(erc20Address);
+            let [from, to, amount] = transfer.arguments;
+            return {
+                token,
+                from: from.value,
+                to: to.value,
+                amount: amount.value
+            };
+        }).toArrayAsync();
+    }
+    async extractFromReceipt(receipt, platform) {
+        let parser = new TxLogParser_1.TxLogParser();
+        let logs = await parser.parse(receipt);
+        logs = logs.filter(x => x != null);
+        return this.extractFromParsed(logs, platform);
+    }
+    async extract(transfer, platform) {
+        let tokenService = TokensServiceFactory_1.TokensServiceFactory.get(platform);
+        let erc20Address = transfer.contract;
+        let token = await tokenService.getTokenOrDefault(erc20Address);
+        let [from, to, amount] = transfer.arguments;
+        return {
+            token,
+            from: from.value,
+            to: to.value,
+            amount: amount.value
+        };
+    }
+}
+exports.TxLogsTransfer = TxLogsTransfer;

package/dist/src/txs/receipt/TxTopicInMemoryProvider.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxTopicInMemoryProvider = void 0;
+const _abiParser_1 = require("@dequanto/utils/$abiParser");
+const _abiUtils_1 = require("@dequanto/utils/$abiUtils");
+class TxTopicInMemoryProvider {
+    constructor() {
+        this.hash = Object.create(null);
+    }
+    register(mix) {
+        if (mix == null) {
+            return this;
+        }
+        if (Array.isArray(mix)) {
+            mix.forEach(x => this.register(x));
+            return this;
+        }
+        let abi;
+        let formatter;
+        if (typeof mix !== 'string' && 'abi' in mix && 'formatter' in mix) {
+            abi = mix.abi;
+            formatter = mix.formatter;
+        }
+        else {
+            abi = mix;
+        }
+        if (typeof abi === 'string') {
+            abi = _abiParser_1.$abiParser.parseMethod(abi);
+        }
+        let hash = _abiUtils_1.$abiUtils.getMethodHash(abi);
+        this.hash[hash] = {
+            abi,
+            formatter
+        };
+        return this;
+    }
+    async get(topicHash) {
+        return this.hash[topicHash];
+    }
+}
+exports.TxTopicInMemoryProvider = TxTopicInMemoryProvider;

package/dist/src/txs/receipt/TxTopicProvider.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxTopicProvider = void 0;
+//import { TxLogsTransfer } from './TxLogsTransfer';
+const TxTopicInMemoryProvider_1 = require("./TxTopicInMemoryProvider");
+class TxTopicProvider {
+    constructor() {
+        this.default = new TxTopicInMemoryProvider_1.TxTopicInMemoryProvider();
+        this.register([
+            'event Transfer(address from, address to, uint256 amount)'
+            // {
+            //     abi: 'event Transfer(address from, address to, uint256 amount)',
+            //     formatter: di.resolve(TxLogsTransfer)
+            // }
+        ]);
+    }
+    async get(topicHash) {
+        return this.default.get(topicHash);
+    }
+    register(mix) {
+        this.default.register(mix);
+        return this;
+    }
+}
+exports.TxTopicProvider = TxTopicProvider;

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

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$abiParser = void 0;
+var $abiParser;
+(function ($abiParser) {
+    function getReturnType(abi) {
+        let outputs = abi.outputs;
+        if (outputs == null || outputs.length == 0) {
+            return 'uint256';
+        }
+        if (outputs.length === 1 && !outputs[0].name) {
+            return outputs[0].type;
+        }
+        let hasKeys = outputs.every(x => Boolean(x.name));
+        if (hasKeys) {
+            return 'object';
+        }
+        return 'array';
+    }
+    $abiParser.getReturnType = getReturnType;
+    function getReturnTypeFromTypes(outputs) {
+        if (outputs == null || outputs.length == 0) {
+            return 'uint256';
+        }
+        if (outputs.length === 1 && !outputs[0].name) {
+            return outputs[0].type;
+        }
+        let hasKeys = outputs.every(x => Boolean(x.name));
+        if (hasKeys) {
+            return 'object';
+        }
+        return 'array';
+    }
+    $abiParser.getReturnTypeFromTypes = getReturnTypeFromTypes;
+    const methodRgx = /^((?<type>function|event)\s+)?(?<methodName>\w+)\s*\((?<params>[^)]+)?\)\s*((:|returns)(?<return>.+))?$/;
+    /**
+     *  foo(uint256):address
+     *  function foo(uint256): (address account, uint256 value)
+     *  function foo(uint256) returns (address)
+     */
+    function parseMethod(methodAbi) {
+        let outputs;
+        let match = methodRgx.exec(methodAbi);
+        if (match == null) {
+            throw new Error(`Invalid method abi ${methodAbi}. Expect like 'foo(uint256):address'`);
+        }
+        let fnName = match.groups.methodName;
+        let $return = match.groups.return?.trim() ?? 'uint256';
+        outputs = parseArguments($return);
+        let inputs = Parse.parametersLine(match.groups.params ?? '');
+        return {
+            constant: false,
+            payable: false,
+            //"stateMutability": "view",
+            name: fnName,
+            inputs: inputs,
+            outputs: outputs,
+            type: match.groups.type ?? 'function',
+        };
+    }
+    $abiParser.parseMethod = parseMethod;
+    // uint256
+    // address[]
+    // (uint256, uint256)
+    // (uint256 foo, uint256 bar)
+    // (uint256 foo, uint256 bar)[]
+    function parseArguments(line) {
+        line = line?.trim();
+        if (!line || line === '()') {
+            return [];
+        }
+        let c = line[0];
+        if (c === '{') {
+            throw new Error(`${line} is not supported, use (...) or [...] declarations`);
+        }
+        if (c === '[' || c === '(') {
+            let end = Parse.goToClosing(line, 0, c);
+            let parametersLine = line.substring(1, end);
+            let isArray = line.endsWith('[]');
+            let params = Parse.parametersLine(parametersLine);
+            let isTuple = params.every(x => Boolean(x.name));
+            if (isTuple && isArray) {
+                return [
+                    {
+                        name: '',
+                        type: `tuple[]`,
+                        components: params
+                    }
+                ];
+            }
+            if (params.length === 1) {
+                line = params[0].type;
+                params = [
+                    {
+                        name: "",
+                        type: line,
+                    },
+                ];
+            }
+            return params;
+        }
+        // if (c === '{') {
+        //     let params = line.substring(1, line.length - 1);
+        //     outputs = params.split(',').map(x => x.trim()).map(param => {
+        //         let [_type, _name] = param.split(/[\s+:]/).map(x => x.trim()).filter(Boolean);
+        //         return {
+        //             name: _name ?? '',
+        //             type: _type.trim()
+        //         };
+        //     });
+        // }
+        return [
+            {
+                name: '',
+                type: line,
+            },
+        ];
+    }
+    $abiParser.parseArguments = parseArguments;
+})($abiParser = exports.$abiParser || (exports.$abiParser = {}));
+var Parse;
+(function (Parse) {
+    // uint256 foo, uint bar, address qux
+    function parametersLine(paramsStr) {
+        return paramsStr
+            .split(',')
+            .map(x => x.trim())
+            .filter(Boolean)
+            .map(param => {
+            let [_type, _name] = param.split(/\s+/).map(x => x.trim()).filter(Boolean);
+            return {
+                name: _name ?? '',
+                type: _type.trim()
+            };
+        });
+    }
+    Parse.parametersLine = parametersLine;
+    function goToClosing(str, startI, openChar, closeChar) {
+        closeChar = closeChar ?? CLOSE_CHARS[openChar];
+        let count = 0;
+        for (let i = startI; i < str.length; i++) {
+            if (str[i] === openChar) {
+                count++;
+            }
+            if (str[i] === closeChar) {
+                count--;
+            }
+            if (count === 0) {
+                return i;
+            }
+        }
+        throw new Error(`Unmatched closing chars ${openChar} ${closeChar} in ${str}`);
+    }
+    Parse.goToClosing = goToClosing;
+    const CLOSE_CHARS = {
+        '[': ']',
+        '(': ')'
+    };
+})(Parse || (Parse = {}));