2021-02-04 19:15:23 +01:00
|
|
|
import EventEmitter from 'safe-event-emitter';
|
|
|
|
import log from 'loglevel';
|
|
|
|
import EthQuery from 'ethjs-query';
|
|
|
|
import { TRANSACTION_STATUSES } from '../../../../shared/constants/transaction';
|
2022-06-13 18:49:18 +02:00
|
|
|
import { ERROR_SUBMITTING } from './tx-state-manager';
|
2018-05-29 00:54:47 +02:00
|
|
|
|
2018-04-13 22:18:45 +02:00
|
|
|
/**
|
2022-01-07 16:57:33 +01:00
|
|
|
* Event emitter utility class for tracking the transactions as they
|
|
|
|
* go from a pending state to a confirmed (mined in a block) state.
|
|
|
|
*
|
|
|
|
* As well as continues broadcast while in the pending state.
|
|
|
|
*/
|
2020-04-27 16:45:00 +02:00
|
|
|
export default class PendingTransactionTracker extends EventEmitter {
|
2020-05-01 19:49:29 +02:00
|
|
|
/**
|
|
|
|
* We wait this many blocks before emitting a 'tx:dropped' event
|
|
|
|
*
|
|
|
|
* This is because we could be talking to a node that is out of sync.
|
|
|
|
*
|
|
|
|
* @type {number}
|
|
|
|
*/
|
2021-02-04 19:15:23 +01:00
|
|
|
DROPPED_BUFFER_COUNT = 3;
|
2020-05-01 19:49:29 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* A map of transaction hashes to the number of blocks we've seen
|
|
|
|
* since first considering it dropped
|
|
|
|
*
|
2022-01-07 16:57:33 +01:00
|
|
|
* @type {Map<string, number>}
|
2020-05-01 19:49:29 +02:00
|
|
|
*/
|
2021-02-04 19:15:23 +01:00
|
|
|
droppedBlocksBufferByHash = new Map();
|
2020-05-01 19:49:29 +02:00
|
|
|
|
2022-01-07 16:57:33 +01:00
|
|
|
/**
|
2022-07-27 15:28:05 +02:00
|
|
|
* @param {object} config - Configuration.
|
2022-01-07 16:57:33 +01:00
|
|
|
* @param {Function} config.approveTransaction - Approves a transaction.
|
|
|
|
* @param {Function} config.confirmTransaction - Set a transaction as confirmed.
|
|
|
|
* @param {Function} config.getCompletedTransactions - Returns completed transactions.
|
|
|
|
* @param {Function} config.getPendingTransactions - Returns an array of pending transactions,
|
2022-07-27 15:28:05 +02:00
|
|
|
* @param {object} config.nonceTracker - see nonce tracker
|
|
|
|
* @param {object} config.provider - A network provider.
|
|
|
|
* @param {object} config.query - An EthQuery instance.
|
2022-01-07 16:57:33 +01:00
|
|
|
* @param {Function} config.publishTransaction - Publishes a raw transaction,
|
|
|
|
*/
|
2020-11-03 00:41:28 +01:00
|
|
|
constructor(config) {
|
2021-02-04 19:15:23 +01:00
|
|
|
super();
|
|
|
|
this.query = config.query || new EthQuery(config.provider);
|
|
|
|
this.nonceTracker = config.nonceTracker;
|
|
|
|
this.getPendingTransactions = config.getPendingTransactions;
|
|
|
|
this.getCompletedTransactions = config.getCompletedTransactions;
|
|
|
|
this.publishTransaction = config.publishTransaction;
|
|
|
|
this.approveTransaction = config.approveTransaction;
|
|
|
|
this.confirmTransaction = config.confirmTransaction;
|
2017-08-04 20:41:35 +02:00
|
|
|
}
|
|
|
|
|
2018-04-13 22:18:45 +02:00
|
|
|
/**
|
2022-01-07 16:57:33 +01:00
|
|
|
* checks the network for signed txs and releases the nonce global lock if it is
|
|
|
|
*/
|
2020-11-03 00:41:28 +01:00
|
|
|
async updatePendingTxs() {
|
2018-05-28 23:29:31 +02:00
|
|
|
// in order to keep the nonceTracker accurate we block it while updating pending transactions
|
2021-02-04 19:15:23 +01:00
|
|
|
const nonceGlobalLock = await this.nonceTracker.getGlobalLock();
|
2018-05-28 23:29:31 +02:00
|
|
|
try {
|
2021-02-04 19:15:23 +01:00
|
|
|
const pendingTxs = this.getPendingTransactions();
|
2020-11-03 00:41:28 +01:00
|
|
|
await Promise.all(
|
|
|
|
pendingTxs.map((txMeta) => this._checkPendingTx(txMeta)),
|
2021-02-04 19:15:23 +01:00
|
|
|
);
|
2018-05-28 23:29:31 +02:00
|
|
|
} catch (err) {
|
2020-11-03 00:41:28 +01:00
|
|
|
log.error(
|
|
|
|
'PendingTransactionTracker - Error updating pending transactions',
|
2021-02-04 19:15:23 +01:00
|
|
|
);
|
|
|
|
log.error(err);
|
2017-08-04 20:41:35 +02:00
|
|
|
}
|
2021-02-04 19:15:23 +01:00
|
|
|
nonceGlobalLock.releaseLock();
|
2017-08-04 20:41:35 +02:00
|
|
|
}
|
|
|
|
|
2018-04-13 22:18:45 +02:00
|
|
|
/**
|
2020-04-23 17:49:04 +02:00
|
|
|
* Resubmits each pending transaction
|
2022-01-07 16:57:33 +01:00
|
|
|
*
|
2020-04-23 17:49:04 +02:00
|
|
|
* @param {string} blockNumber - the latest block number in hex
|
2022-01-07 16:57:33 +01:00
|
|
|
* @fires tx:warning
|
2020-04-27 17:54:39 +02:00
|
|
|
* @returns {Promise<void>}
|
2020-04-23 17:49:04 +02:00
|
|
|
*/
|
2020-11-03 00:41:28 +01:00
|
|
|
async resubmitPendingTxs(blockNumber) {
|
2021-02-04 19:15:23 +01:00
|
|
|
const pending = this.getPendingTransactions();
|
2019-11-20 01:03:20 +01:00
|
|
|
if (!pending.length) {
|
2021-02-04 19:15:23 +01:00
|
|
|
return;
|
2019-11-20 01:03:20 +01:00
|
|
|
}
|
2020-04-27 17:54:39 +02:00
|
|
|
for (const txMeta of pending) {
|
|
|
|
try {
|
2021-02-04 19:15:23 +01:00
|
|
|
await this._resubmitTx(txMeta, blockNumber);
|
2020-04-27 17:54:39 +02:00
|
|
|
} catch (err) {
|
2020-11-03 00:41:28 +01:00
|
|
|
const errorMessage =
|
2021-02-04 19:15:23 +01:00
|
|
|
err.value?.message?.toLowerCase() || err.message.toLowerCase();
|
2020-11-03 00:41:28 +01:00
|
|
|
const isKnownTx =
|
2020-04-27 17:54:39 +02:00
|
|
|
// geth
|
|
|
|
errorMessage.includes('replacement transaction underpriced') ||
|
|
|
|
errorMessage.includes('known transaction') ||
|
|
|
|
// parity
|
|
|
|
errorMessage.includes('gas price too low to replace') ||
|
2020-11-03 00:41:28 +01:00
|
|
|
errorMessage.includes(
|
|
|
|
'transaction with the same hash was already imported',
|
|
|
|
) ||
|
2020-04-27 17:54:39 +02:00
|
|
|
// other
|
|
|
|
errorMessage.includes('gateway timeout') ||
|
2021-02-04 19:15:23 +01:00
|
|
|
errorMessage.includes('nonce too low');
|
2020-04-27 17:54:39 +02:00
|
|
|
// ignore resubmit warnings, return early
|
|
|
|
if (isKnownTx) {
|
2021-02-04 19:15:23 +01:00
|
|
|
return;
|
2020-04-27 17:54:39 +02:00
|
|
|
}
|
|
|
|
// encountered real error - transition to error state
|
|
|
|
txMeta.warning = {
|
|
|
|
error: errorMessage,
|
2022-06-13 18:49:18 +02:00
|
|
|
message: ERROR_SUBMITTING,
|
2021-02-04 19:15:23 +01:00
|
|
|
};
|
|
|
|
this.emit('tx:warning', txMeta, err);
|
2017-10-03 00:00:23 +02:00
|
|
|
}
|
2020-04-27 17:54:39 +02:00
|
|
|
}
|
2017-08-04 20:41:35 +02:00
|
|
|
}
|
|
|
|
|
2018-04-13 22:18:45 +02:00
|
|
|
/**
|
2020-04-23 17:49:04 +02:00
|
|
|
* Attempts to resubmit the given transaction with exponential backoff
|
|
|
|
*
|
|
|
|
* Will only attempt to retry the given tx every {@code 2**(txMeta.retryCount)} blocks.
|
|
|
|
*
|
2022-07-27 15:28:05 +02:00
|
|
|
* @param {object} txMeta - the transaction metadata
|
2020-04-23 17:49:04 +02:00
|
|
|
* @param {string} latestBlockNumber - the latest block number in hex
|
|
|
|
* @returns {Promise<string|undefined>} the tx hash if retried
|
2022-01-07 16:57:33 +01:00
|
|
|
* @fires tx:block-update
|
|
|
|
* @fires tx:retry
|
2020-04-23 17:49:04 +02:00
|
|
|
* @private
|
|
|
|
*/
|
2020-11-03 00:41:28 +01:00
|
|
|
async _resubmitTx(txMeta, latestBlockNumber) {
|
2017-12-05 21:51:14 +01:00
|
|
|
if (!txMeta.firstRetryBlockNumber) {
|
2021-02-04 19:15:23 +01:00
|
|
|
this.emit('tx:block-update', txMeta, latestBlockNumber);
|
2017-12-05 21:51:14 +01:00
|
|
|
}
|
|
|
|
|
2020-11-03 00:41:28 +01:00
|
|
|
const firstRetryBlockNumber =
|
2021-02-04 19:15:23 +01:00
|
|
|
txMeta.firstRetryBlockNumber || latestBlockNumber;
|
2020-11-03 00:41:28 +01:00
|
|
|
const txBlockDistance =
|
|
|
|
Number.parseInt(latestBlockNumber, 16) -
|
2021-02-04 19:15:23 +01:00
|
|
|
Number.parseInt(firstRetryBlockNumber, 16);
|
2017-12-05 21:51:14 +01:00
|
|
|
|
2021-02-04 19:15:23 +01:00
|
|
|
const retryCount = txMeta.retryCount || 0;
|
2017-12-05 21:51:14 +01:00
|
|
|
|
2021-09-02 23:06:31 +02:00
|
|
|
// Exponential backoff to limit retries at publishing (capped at ~15 minutes between retries)
|
|
|
|
if (txBlockDistance < Math.min(50, Math.pow(2, retryCount))) {
|
2021-02-04 19:15:23 +01:00
|
|
|
return undefined;
|
2019-11-20 01:03:20 +01:00
|
|
|
}
|
2017-12-05 21:51:14 +01:00
|
|
|
|
2017-08-04 20:41:35 +02:00
|
|
|
// Only auto-submit already-signed txs:
|
2019-11-20 01:03:20 +01:00
|
|
|
if (!('rawTx' in txMeta)) {
|
2021-02-04 19:15:23 +01:00
|
|
|
return this.approveTransaction(txMeta.id);
|
2019-11-20 01:03:20 +01:00
|
|
|
}
|
2017-08-04 20:41:35 +02:00
|
|
|
|
2021-02-04 19:15:23 +01:00
|
|
|
const { rawTx } = txMeta;
|
|
|
|
const txHash = await this.publishTransaction(rawTx);
|
2017-09-18 23:34:25 +02:00
|
|
|
|
|
|
|
// Increment successful tries:
|
2021-02-04 19:15:23 +01:00
|
|
|
this.emit('tx:retry', txMeta);
|
|
|
|
return txHash;
|
2017-08-04 20:41:35 +02:00
|
|
|
}
|
2018-05-28 23:29:31 +02:00
|
|
|
|
2018-04-13 22:18:45 +02:00
|
|
|
/**
|
2020-04-23 17:49:04 +02:00
|
|
|
* Query the network to see if the given {@code txMeta} has been included in a block
|
2022-01-07 16:57:33 +01:00
|
|
|
*
|
2022-07-27 15:28:05 +02:00
|
|
|
* @param {object} txMeta - the transaction metadata
|
2020-04-23 17:49:04 +02:00
|
|
|
* @returns {Promise<void>}
|
2022-01-07 16:57:33 +01:00
|
|
|
* @fires tx:confirmed
|
|
|
|
* @fires tx:dropped
|
|
|
|
* @fires tx:failed
|
|
|
|
* @fires tx:warning
|
2020-04-23 17:49:04 +02:00
|
|
|
* @private
|
|
|
|
*/
|
2021-12-07 19:16:40 +01:00
|
|
|
|
2020-11-03 00:41:28 +01:00
|
|
|
async _checkPendingTx(txMeta) {
|
2021-02-04 19:15:23 +01:00
|
|
|
const txHash = txMeta.hash;
|
|
|
|
const txId = txMeta.id;
|
2017-10-06 21:51:13 +02:00
|
|
|
|
2018-11-14 22:34:07 +01:00
|
|
|
// Only check submitted txs
|
2020-11-07 08:38:12 +01:00
|
|
|
if (txMeta.status !== TRANSACTION_STATUSES.SUBMITTED) {
|
2021-02-04 19:15:23 +01:00
|
|
|
return;
|
2019-11-20 01:03:20 +01:00
|
|
|
}
|
2018-11-14 22:34:07 +01:00
|
|
|
|
2017-08-04 20:41:35 +02:00
|
|
|
// extra check in case there was an uncaught error during the
|
|
|
|
// signature and submission process
|
|
|
|
if (!txHash) {
|
2020-11-03 00:41:28 +01:00
|
|
|
const noTxHashErr = new Error(
|
|
|
|
'We had an error while submitting this transaction, please try again.',
|
2021-02-04 19:15:23 +01:00
|
|
|
);
|
|
|
|
noTxHashErr.name = 'NoTxHashError';
|
|
|
|
this.emit('tx:failed', txId, noTxHashErr);
|
2019-05-16 07:36:53 +02:00
|
|
|
|
2021-02-04 19:15:23 +01:00
|
|
|
return;
|
2017-08-04 20:41:35 +02:00
|
|
|
}
|
2020-04-17 18:53:46 +02:00
|
|
|
|
2020-05-01 19:49:29 +02:00
|
|
|
if (await this._checkIfNonceIsTaken(txMeta)) {
|
2021-02-04 19:15:23 +01:00
|
|
|
this.emit('tx:dropped', txId);
|
|
|
|
return;
|
2017-10-06 21:51:13 +02:00
|
|
|
}
|
|
|
|
|
2020-05-01 19:49:29 +02:00
|
|
|
try {
|
2021-02-04 19:15:23 +01:00
|
|
|
const transactionReceipt = await this.query.getTransactionReceipt(txHash);
|
2020-05-01 19:49:29 +02:00
|
|
|
if (transactionReceipt?.blockNumber) {
|
2022-07-31 20:26:40 +02:00
|
|
|
const { baseFeePerGas, timestamp: blockTimestamp } =
|
|
|
|
await this.query.getBlockByHash(transactionReceipt?.blockHash, false);
|
2021-12-07 19:16:40 +01:00
|
|
|
|
|
|
|
this.emit(
|
|
|
|
'tx:confirmed',
|
|
|
|
txId,
|
|
|
|
transactionReceipt,
|
|
|
|
baseFeePerGas,
|
|
|
|
blockTimestamp,
|
|
|
|
);
|
2021-02-04 19:15:23 +01:00
|
|
|
return;
|
2020-05-01 19:49:29 +02:00
|
|
|
}
|
|
|
|
} catch (err) {
|
2017-08-04 20:41:35 +02:00
|
|
|
txMeta.warning = {
|
2017-10-03 00:39:11 +02:00
|
|
|
error: err.message,
|
2017-08-04 20:41:35 +02:00
|
|
|
message: 'There was a problem loading this transaction.',
|
2021-02-04 19:15:23 +01:00
|
|
|
};
|
|
|
|
this.emit('tx:warning', txMeta, err);
|
|
|
|
return;
|
2020-05-01 19:49:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (await this._checkIfTxWasDropped(txMeta)) {
|
2021-02-04 19:15:23 +01:00
|
|
|
this.emit('tx:dropped', txId);
|
2017-08-04 20:41:35 +02:00
|
|
|
}
|
|
|
|
}
|
2019-05-16 07:36:53 +02:00
|
|
|
|
2020-04-23 17:49:04 +02:00
|
|
|
/**
|
2020-05-01 19:49:29 +02:00
|
|
|
* Checks whether the nonce in the given {@code txMeta} is behind the network nonce
|
|
|
|
*
|
2022-07-27 15:28:05 +02:00
|
|
|
* @param {object} txMeta - the transaction metadata
|
2020-04-23 17:49:04 +02:00
|
|
|
* @returns {Promise<boolean>}
|
|
|
|
* @private
|
|
|
|
*/
|
2020-11-03 00:41:28 +01:00
|
|
|
async _checkIfTxWasDropped(txMeta) {
|
|
|
|
const {
|
|
|
|
hash: txHash,
|
|
|
|
txParams: { nonce, from },
|
2021-02-04 19:15:23 +01:00
|
|
|
} = txMeta;
|
|
|
|
const networkNextNonce = await this.query.getTransactionCount(from);
|
2020-05-01 19:49:29 +02:00
|
|
|
|
2020-06-17 23:13:33 +02:00
|
|
|
if (parseInt(nonce, 16) >= networkNextNonce.toNumber()) {
|
2021-02-04 19:15:23 +01:00
|
|
|
return false;
|
2020-05-01 19:49:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!this.droppedBlocksBufferByHash.has(txHash)) {
|
2021-02-04 19:15:23 +01:00
|
|
|
this.droppedBlocksBufferByHash.set(txHash, 0);
|
2020-05-01 19:49:29 +02:00
|
|
|
}
|
|
|
|
|
2021-02-04 19:15:23 +01:00
|
|
|
const currentBlockBuffer = this.droppedBlocksBufferByHash.get(txHash);
|
2020-05-01 19:49:29 +02:00
|
|
|
|
|
|
|
if (currentBlockBuffer < this.DROPPED_BUFFER_COUNT) {
|
2021-02-04 19:15:23 +01:00
|
|
|
this.droppedBlocksBufferByHash.set(txHash, currentBlockBuffer + 1);
|
|
|
|
return false;
|
2020-05-01 19:49:29 +02:00
|
|
|
}
|
|
|
|
|
2021-02-04 19:15:23 +01:00
|
|
|
this.droppedBlocksBufferByHash.delete(txHash);
|
|
|
|
return true;
|
2019-05-16 07:36:53 +02:00
|
|
|
}
|
2017-08-04 20:41:35 +02:00
|
|
|
|
2018-04-13 22:18:45 +02:00
|
|
|
/**
|
2020-04-23 17:49:04 +02:00
|
|
|
* Checks whether the nonce in the given {@code txMeta} is correct against the local set of transactions
|
2022-01-07 16:57:33 +01:00
|
|
|
*
|
2022-07-27 15:28:05 +02:00
|
|
|
* @param {object} txMeta - the transaction metadata
|
2020-04-23 17:49:04 +02:00
|
|
|
* @returns {Promise<boolean>}
|
|
|
|
* @private
|
|
|
|
*/
|
2020-11-03 00:41:28 +01:00
|
|
|
async _checkIfNonceIsTaken(txMeta) {
|
2021-02-04 19:15:23 +01:00
|
|
|
const address = txMeta.txParams.from;
|
|
|
|
const completed = this.getCompletedTransactions(address);
|
2020-08-13 01:49:10 +02:00
|
|
|
return completed.some(
|
2020-04-27 23:08:16 +02:00
|
|
|
// This is called while the transaction is in-flight, so it is possible that the
|
|
|
|
// list of completed transactions now includes the transaction we were looking at
|
|
|
|
// and if that is the case, don't consider the transaction to have taken its own nonce
|
2020-11-03 00:41:28 +01:00
|
|
|
(other) =>
|
|
|
|
!(other.id === txMeta.id) &&
|
|
|
|
other.txParams.nonce === txMeta.txParams.nonce,
|
2021-02-04 19:15:23 +01:00
|
|
|
);
|
2017-10-06 21:51:13 +02:00
|
|
|
}
|
2017-08-24 07:29:08 +02:00
|
|
|
}
|