dequanto 0.0.1

package/dist/src/txs/TxDataBuilder.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxDataBuilder = void 0;
+const InputDataUtils_1 = require("@dequanto/contracts/utils/InputDataUtils");
+const _bigint_1 = require("@dequanto/utils/$bigint");
+class TxDataBuilder {
+    constructor(client, account, data, config = null) {
+        this.client = client;
+        this.account = account;
+        this.data = data;
+        this.config = config;
+        this.data.value = this.data.value ?? 0;
+    }
+    setInputDataWithTypes(types, paramaters) {
+        this.data.data = InputDataUtils_1.InputDataUtils.encodeWithTypes(this.client, types, paramaters);
+        return this;
+    }
+    setInputDataWithABI(IFunctionABI, ...params) {
+        try {
+            this.data.data = InputDataUtils_1.InputDataUtils.encodeWithABI(IFunctionABI, ...params);
+        }
+        catch (error) {
+            error.message = `${JSON.stringify(IFunctionABI)}\n${error.message}`;
+            throw error;
+        }
+        return this;
+    }
+    setValue(value) {
+        if (value == null) {
+            return this;
+        }
+        if (typeof value === 'number') {
+            value = _bigint_1.$bigint.toWei(value);
+        }
+        if (typeof value === 'bigint') {
+            this.data.value = `0x${value.toString(16)}`;
+            return this;
+        }
+        this.data.value = value;
+        return this;
+    }
+    setConfig(config) {
+        this.config = config;
+        return this;
+    }
+    async setNonce(opts) {
+        let nonce;
+        if (opts?.nonce != null) {
+            nonce = opts.nonce;
+        }
+        else if (opts?.overriding) {
+            nonce = await this.client.getTransactionCount(this.account.address);
+            // override first pending TX:
+        }
+        else if (opts?.noncePending != null) {
+            let pendingIndex = opts.noncePending - 1;
+            let submited = await this.client.getTransactionCount(this.account.address);
+            let next = pendingIndex;
+            if (next > 0) {
+                let total = await this.client.getTransactionCount(this.account.address, 'pending');
+                let pendingCount = total - submited;
+                if (pendingCount > 0 && next > pendingCount - 1) {
+                    next = pendingCount - 1;
+                }
+            }
+            nonce = submited + next;
+        }
+        else {
+            nonce = await this.client.getTransactionCount(this.account.address, 'pending');
+        }
+        // let count = opts?.nonce ?? (
+        //     opts?.overriding === true
+        //     ? await this.client.getTransactionCount(this.account.address)
+        //     : await this.client.getTransactionCount(this.account.address, 'pending')
+        // );
+        //let nonce = count;
+        this.data.nonce = nonce;
+    }
+    async setGas({ price, priceRatio, gasLimitRatio, gasLimit, gasEstimation, from, type, } = {}) {
+        let [gasPrice, gasUsage] = await Promise.all([
+            price != null ?
+                { price, base: price, priority: 10n ** 9n }
+                : this.client.getGasPrice(),
+            gasEstimation
+                ? this.client.getGasEstimation(from, this.data)
+                : (gasLimit ?? this.client.defaultGasLimit ?? 2000000)
+        ]);
+        let hasPriceRatio = priceRatio != null;
+        let hasPriceFixed = price != null;
+        let $priceRatio = 1;
+        if (hasPriceRatio) {
+            $priceRatio = priceRatio;
+        }
+        else if (hasPriceFixed === false) {
+            $priceRatio = 1.4;
+        }
+        if (type === 1) {
+            let $baseFee = _bigint_1.$bigint.multWithFloat(gasPrice.price, $priceRatio);
+            this.data.gasPrice = _bigint_1.$bigint.toHex($baseFee);
+        }
+        else {
+            let $baseFee = _bigint_1.$bigint.multWithFloat(gasPrice.base ?? gasPrice.price, $priceRatio);
+            let $priorityFee = gasPrice.priority ?? 10n ** 9n;
+            this.data.maxFeePerGas = _bigint_1.$bigint.toHex($baseFee + $priorityFee);
+            this.data.maxPriorityFeePerGas = _bigint_1.$bigint.toHex($priorityFee);
+            this.data.type = '0x02';
+        }
+        let hasLimitRatio = gasLimitRatio != null;
+        let hasLimitFixed = gasLimit != null;
+        let $gasLimitRatio = 1;
+        if (hasLimitRatio) {
+            $gasLimitRatio = gasLimitRatio;
+        }
+        else if (hasLimitFixed === false) {
+            $gasLimitRatio = 1.5;
+        }
+        this.data.gasLimit = gasLimit ?? Math.floor(Number(gasUsage) * $gasLimitRatio);
+        return this;
+    }
+    increaseGas(ratio) {
+        let gasPrice = this.data.gasPrice;
+        if (gasPrice == null) {
+            throw new Error(`Not possible to increase the gas price, the price not set yet`);
+        }
+        let price = BigInt(this.data.gasPrice);
+        let priceNew = _bigint_1.$bigint.multWithFloat(price, ratio);
+        this.data.gasPrice = _bigint_1.$bigint.toHex(priceNew);
+    }
+    signToBuffer(privateKey) {
+        return this.client.sign(this.data, privateKey);
+    }
+    signToString(privateKey) {
+        if (privateKey.startsWith('0x')) {
+            privateKey = privateKey.substring(2);
+        }
+        let buffer = this.signToBuffer(privateKey);
+        return '0x' + buffer.toString('hex');
+    }
+    toJSON() {
+        return {
+            config: this.config,
+            data: this.data,
+        };
+    }
+    static fromJSON(client, account, json) {
+        return new TxDataBuilder(client, account, json.data, json.config);
+    }
+    static normalize(data) {
+        for (let key in data) {
+            let v = data[key];
+            if (typeof v === 'string' && /^\d+$/.test(v)) {
+                data[key] = BigInt(v);
+            }
+        }
+        return data;
+    }
+}
+exports.TxDataBuilder = TxDataBuilder;
+TxDataBuilder.nonce = -1;

package/dist/src/txs/TxLogger.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxLogger = void 0;
+const _logger_1 = require("@dequanto/utils/$logger");
+const everlog_1 = require("everlog");
+class TxLogger {
+    constructor(id, from, builder) {
+        this.id = id;
+        this.from = from;
+        this.builder = builder;
+    }
+    log(message) {
+        _logger_1.$logger.log('TxLog:', message);
+        channels.log.writeRow([
+            new Date(),
+            'LOG',
+            this.id,
+            message
+        ]);
+    }
+    logStart() {
+        channels.start.writeRow([
+            new Date(),
+            this.id,
+            this.from,
+            this.builder.data.to,
+            this.builder.data.data?.toString()
+        ]);
+    }
+    logReceipt(receipt, time) {
+        channels.receipt.writeRow([
+            new Date(),
+            this.id,
+            receipt.transactionHash,
+            receipt.status,
+            time,
+        ]);
+    }
+    logError(error) {
+        _logger_1.$logger.log('TxError:', error.message);
+        channels.log.writeRow([
+            new Date(),
+            'ERROR',
+            this.id,
+            error.message
+        ]);
+    }
+}
+exports.TxLogger = TxLogger;
+const channels = {
+    start: everlog_1.Monit.createChannel('tx-starts', {
+        columns: [
+            {
+                type: 'date',
+                name: 'Date'
+            },
+            {
+                type: 'string',
+                name: 'ID'
+            },
+            {
+                type: 'string',
+                name: 'From'
+            },
+            {
+                type: 'string',
+                name: 'To'
+            },
+            {
+                type: 'string',
+                name: 'Method'
+            }
+        ]
+    }),
+    log: everlog_1.Monit.createChannel('tx-logs', {
+        columns: [
+            {
+                type: 'date',
+                name: 'Date'
+            },
+            {
+                type: 'string',
+                name: 'Level'
+            },
+            {
+                type: 'string',
+                name: 'TxID'
+            },
+            {
+                type: 'string',
+                name: 'Error'
+            }
+        ]
+    }),
+    receipt: everlog_1.Monit.createChannel('tx-receipts', {
+        columns: [
+            {
+                type: 'date',
+                name: 'Date'
+            },
+            {
+                type: 'string',
+                name: 'ID'
+            },
+            {
+                type: 'string',
+                name: 'TxHash'
+            },
+            {
+                type: 'string',
+                name: 'Status'
+            },
+            {
+                type: 'number',
+                name: 'Duration'
+            }
+        ]
+    }),
+};

package/dist/src/txs/TxProvider.js

@@ -0,0 +1,73 @@
+"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.TxProvider = void 0;
+const EthWeb3Client_1 = require("@dequanto/clients/EthWeb3Client");
+const a_di_1 = __importDefault(require("a-di"));
+const memd_1 = __importDefault(require("memd"));
+class TxProvider {
+    constructor(client = a_di_1.default.resolve(EthWeb3Client_1.EthWeb3Client)) {
+        this.client = client;
+        this.cache = CacheProvider.create(`./cache/${this.client.platform}/txs.json`);
+    }
+    async loadTransaction(txHash) {
+        let tx = await this.client.getTransaction(txHash);
+        return tx;
+    }
+    async loadTransactionCached(txHash) {
+        return this.fromCache(`tx.${txHash}`, () => this.loadTransaction(txHash));
+    }
+    async loadTransactionReceipt(txHash) {
+        let receipt = await this.client.getTransactionReceipt(txHash);
+        return receipt;
+    }
+    async loadTransactionReceiptCached(txHash) {
+        return this.fromCache(`receipt.${txHash}`, () => this.loadTransactionReceipt(txHash));
+    }
+    async loadBlock(blockNumber) {
+        let block = await this.client.getBlock(blockNumber);
+        return block;
+    }
+    async loadBlockCached(blockNumber) {
+        return this.fromCache(`block.${blockNumber}`, () => this.loadBlock(blockNumber));
+    }
+    async fromCache(key, fn) {
+        let cached = await this.cache.getAsync(key);
+        if (cached) {
+            return cached;
+        }
+        let val = await fn();
+        await this.cache.setAsync(key, val);
+        return val;
+    }
+}
+__decorate([
+    memd_1.default.deco.memoize()
+], TxProvider.prototype, "loadTransactionCached", null);
+__decorate([
+    memd_1.default.deco.memoize()
+], TxProvider.prototype, "loadTransactionReceiptCached", null);
+__decorate([
+    memd_1.default.deco.memoize()
+], TxProvider.prototype, "loadBlockCached", null);
+exports.TxProvider = TxProvider;
+class CacheProvider {
+    static create(path) {
+        let cache = new memd_1.default.Cache({
+            persistance: new memd_1.default.FsTransport({ path }),
+            trackRef: true
+        });
+        return cache;
+    }
+}
+__decorate([
+    memd_1.default.deco.memoize()
+], CacheProvider, "create", null);

package/dist/src/txs/TxService.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxService = void 0;
+class TxService {
+    constructor(client) {
+        this.client = client;
+    }
+    async cancelTx(hash) {
+        let tx = await this.client.getTransaction(hash);
+        if (tx == null) {
+            throw new Error(`Tx ${hash} not found`);
+        }
+        if (tx.blockNumber) {
+            throw new Error(`Tx ${hash} was already mined in block ${tx.blockNumber}`);
+        }
+        console.log(tx);
+    }
+}
+exports.TxService = TxService;

package/dist/src/txs/TxWriter.js

@@ -0,0 +1,287 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxWriter = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const atma_utils_1 = require("atma-utils");
+const TxDataBuilder_1 = require("./TxDataBuilder");
+const TxLogger_1 = require("./TxLogger");
+require("../env/BigIntSerializer");
+const _bigint_1 = require("@dequanto/utils/$bigint");
+const ChainAccountsService_1 = require("@dequanto/ChainAccountsService");
+const Web3ClientFactory_1 = require("@dequanto/clients/Web3ClientFactory");
+const _promise_1 = require("@dequanto/utils/$promise");
+const ClientErrorUtil_1 = require("@dequanto/clients/utils/ClientErrorUtil");
+const _logger_1 = require("@dequanto/utils/$logger");
+const TxLogParser_1 = require("./receipt/TxLogParser");
+class TxWriter extends atma_utils_1.class_EventEmitter {
+    constructor(client, builder, account) {
+        super();
+        this.client = client;
+        this.builder = builder;
+        this.account = account;
+        this.onSent = new atma_utils_1.class_Dfr();
+        this.onCompleted = new atma_utils_1.class_Dfr();
+        this.id = Math.round(Math.random() * 10 ** 10) + '';
+        this.tx = null;
+        this.txs = [];
+        this.logger = new TxLogger_1.TxLogger(this.id, this.account.name ?? this.account.key, this.builder);
+        this.confirmationAwaiters = [];
+    }
+    onConfirmed(waitForCount) {
+        let promise = new atma_utils_1.class_Dfr();
+        if (this.tx.confirmations >= waitForCount) {
+            promise.resolve(this.tx.hash);
+        }
+        else {
+            this.confirmationAwaiters.push({
+                count: waitForCount,
+                promise
+            });
+        }
+        return promise;
+    }
+    send(options) {
+        if (this.tx == null) {
+            this.logger.logStart();
+            this.onCompleted.defer();
+            this.onSent.defer();
+            // was not sent
+            this.options = options;
+            this.sendTxInner();
+        }
+        return this;
+    }
+    write(options) {
+        if (this.builder?.config?.send !== 'manual') {
+            this.send(options);
+        }
+    }
+    sendTxInner() {
+        let time = Date.now();
+        let signedTxBuffer = this.builder.signToString(this.account.key);
+        let tx = {
+            timestamp: Date.now(),
+            confirmations: 0,
+            hash: null,
+            receipt: null,
+            timeout: null,
+        };
+        tx.timeout = this.startTimer(tx);
+        this.tx = tx;
+        this.txs.push(tx);
+        let promiEvent = this
+            .client
+            .sendSignedTransaction(signedTxBuffer)
+            .once('transactionHash', hash => {
+            if (tx.hash && tx.timeout) {
+                // network has reaccepted the tx, restart previous timeout
+                this.clearTimer(tx);
+                tx.timeout = this.startTimer(tx);
+            }
+            tx.hash = hash;
+            this.onSent.resolve(hash);
+            this.emit('transactionHash', hash);
+            this.emit('log', `Tx hash received: ${hash}`);
+        })
+            .once('receipt', receipt => {
+            tx.receipt = receipt;
+            tx.hash = receipt.transactionHash ?? tx.hash;
+            this.receipt = receipt;
+            this.clearTimer(tx);
+            this.logger.logReceipt(receipt, Date.now() - time);
+            this.onSent.resolve();
+            this.emit('receipt', receipt);
+            this.emit('log', `Tx receipt received for ${receipt.transactionHash}. Status: ${receipt.status}`);
+        })
+            // .on('confirmation', (confNumber, receipt) => {
+            //     tx.hash = receipt.transactionHash ?? tx.hash;
+            //     this.onSent.resolve();
+            //     this.emit('confirmation', confNumber, receipt);
+            //     this.emit('log', `Tx confirmation received for ${tx.hash}. Confirmations: ${confNumber}`);
+            //     let arr = this.confirmationAwaiters;
+            //     for (let i = 0; i < arr.length; i++) {
+            //         if (confNumber >= arr[i].count) {
+            //             arr[i].promise.resolve();
+            //             arr.splice(i, 1);
+            //             i--;
+            //         }
+            //     }
+            // })
+            .on('error', error => {
+            this.clearTimer(tx);
+            this.logger.logError(error);
+            this.emit('error', error);
+            this.emit('log', `Tx ERROR "${error.message}"`);
+        })
+            .then(async (receipt) => {
+            this.clearTimer(tx);
+            try {
+                await this.extractLogs(receipt, tx);
+            }
+            catch (error) { }
+            this.onCompleted.resolve(receipt);
+        }, async (err) => {
+            this.clearTimer(tx);
+            tx.error = err;
+            const options = this.options ?? {};
+            if (err.receipt?.status === false) {
+                // read reason
+                // let client = await this.client.getWeb3();
+                // let tx = await this.client.getTransaction(err.receipt.transactionHash);
+                // console.log('RECEIPT', err.receipt, tx);
+                // try {
+                //     let result = await client.eth.call(tx, tx.blockNumber);
+                //     console.log('RESULT', result);
+                // } catch (err) {
+                //     console.log('CALL ERROR', err);
+                // }
+                // throw new Error('asd');
+            }
+            if (ClientErrorUtil_1.ClientErrorUtil.IsInsufficientFunds(err)) {
+                if (this.builder.config?.gasFunding) {
+                    this.fundAccountAndResend().catch(err => {
+                        this.onCompleted.reject(err);
+                    });
+                    return;
+                }
+                if (options.retries == null) {
+                    options.retries = 1;
+                    options.retryDelay = 5000;
+                    // If insufficient funds this is can be due to the blockchain hasn't confirmed some incomming transactions
+                }
+            }
+            if (ClientErrorUtil_1.ClientErrorUtil.IsNonceTooLow(err)) {
+                if (options.retries == null) {
+                    options.retries = 1;
+                }
+                let nonce = this.builder.data.nonce;
+                // reset nonce
+                await this.builder.setNonce();
+                this.logger.log(`Nonce was ${Number(nonce)} too low. Reetries left: ${options.retries}. New nonce: ${Number(this.builder.data.nonce)}`);
+            }
+            let submitsCount = this.txs.length;
+            let submitsMax = (options.retries ?? 0) + 1;
+            if (submitsCount < submitsMax) {
+                let ms = options.retryDelay ?? 3000;
+                let waitMs = ms * submitsCount;
+                _logger_1.$logger.log(`Tx retry in ${waitMs}ms`);
+                await _promise_1.$promise.wait(waitMs);
+                let onErrorRebuild = options.onErrorRebuild;
+                if (onErrorRebuild != null) {
+                    let txBuilder = await onErrorRebuild(this, err, submitsCount);
+                    if (txBuilder != null) {
+                        this.builder = txBuilder;
+                    }
+                }
+                this.resubmit({ increaseGas: false });
+                return;
+            }
+            this.onCompleted.reject(err);
+        });
+    }
+    async extractLogs(receipt, tx) {
+        let parser = a_di_1.default.resolve(TxLogParser_1.TxLogParser);
+        let logs = await parser.parse(receipt);
+        tx.knownLogs = logs.filter(x => x != null);
+    }
+    async fundAccountAndResend() {
+        let account = this.builder.config.gasFunding;
+        await this.builder.setGas({
+            gasEstimation: true,
+            from: this.account.address
+        });
+        let { gasPrice, gasLimit } = this.builder.data;
+        let LITTLE_BIT_MORE = 1.3;
+        let wei = _bigint_1.$bigint.multWithFloat(BigInt(gasPrice) * BigInt(gasLimit), LITTLE_BIT_MORE);
+        let fundTx = await this.transferNative(account, this.account.address, wei);
+        await fundTx.onCompleted;
+        // account was funded resubmit the tx
+        this.resubmit();
+    }
+    startTimer(tx) {
+        let timeout = this.options?.timeout;
+        let ms;
+        if (typeof timeout === 'boolean') {
+            if (timeout === false) {
+                // Timeout was disabled
+                return null;
+            }
+            ms = this.client.TIMEOUT;
+        }
+        else {
+            ms = timeout ?? this.client.TIMEOUT;
+        }
+        return setTimeout(() => {
+            if (this.txs.length > 3) {
+                let hashes = this.txs.map(x => x.hash).join(', ');
+                this.onCompleted.reject(new Error(`${this.txs.length} retries timeouted, with hashes: ${hashes}`));
+                return;
+            }
+            tx.error = new Error(`Timeouted ${ms}ms`);
+            this.resubmit();
+        }, ms);
+    }
+    clearTimer(tx) {
+        if (tx.timeout) {
+            clearTimeout(tx.timeout);
+            tx.timeout = null;
+        }
+    }
+    resubmit({ increaseGas = true } = {}) {
+        if (increaseGas !== false) {
+            this.builder.increaseGas(1.1);
+        }
+        this.sendTxInner();
+    }
+    /** Use this transfer in case of additional account funding */
+    async transferNative(from, to, amount) {
+        let txBuilder = new TxDataBuilder_1.TxDataBuilder(this.client, from, {
+            to: to,
+            value: _bigint_1.$bigint.toHex(amount)
+        });
+        let GAS = 21000;
+        await Promise.all([
+            txBuilder.setGas({ gasLimit: GAS }),
+            txBuilder.setNonce(),
+        ]);
+        return TxWriter.write(this.client, txBuilder, from);
+    }
+    toJSON() {
+        return {
+            id: this.id,
+            platform: this.client.platform,
+            options: this.options,
+            account: this.account.address,
+            txs: this.txs,
+            builder: this.builder.toJSON(),
+        };
+    }
+    static async fromJSON(json, client) {
+        client = client ?? Web3ClientFactory_1.Web3ClientFactory.get(json.platform);
+        let service = a_di_1.default.resolve(ChainAccountsService_1.ChainAccountsService);
+        let account = await service.get(json.account, json.platform);
+        let builder = TxDataBuilder_1.TxDataBuilder.fromJSON(client, account, {
+            config: json.builder.config,
+            data: json.builder.data,
+        });
+        let writer = TxWriter.create(client, builder, account, json.options);
+        let txs = json.txs;
+        writer.id = json.id;
+        writer.tx = txs[txs.length - 1];
+        writer.txs = txs;
+        writer.receipt = txs.find(x => x.receipt)?.receipt;
+        return writer;
+    }
+    static write(client, builder, account, options) {
+        let writer = new TxWriter(client, builder, account);
+        writer.write(options);
+        return writer;
+    }
+    static create(client, builder, account, options) {
+        return new TxWriter(client, builder, account);
+    }
+}
+exports.TxWriter = TxWriter;