1
0
mirror of https://github.com/kremalicious/metamask-extension.git synced 2024-12-04 23:14:56 +01:00
metamask-extension/app/scripts/controllers/transactions/pending-tx-tracker.js

280 lines
8.7 KiB
JavaScript
Raw Normal View History

import EventEmitter from 'safe-event-emitter';
import log from 'loglevel';
import EthQuery from 'ethjs-query';
import { TRANSACTION_STATUSES } from '../../../../shared/constants/transaction';
import { ERROR_SUBMITTING } from './tx-state-manager';
2018-04-13 22:18:45 +02: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.
*/
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}
*/
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
*
* @type {Map<string, number>}
2020-05-01 19:49:29 +02:00
*/
droppedBlocksBufferByHash = new Map();
2020-05-01 19:49:29 +02:00
/**
* @param {object} config - Configuration.
* @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,
* @param {object} config.nonceTracker - see nonce tracker
* @param {object} config.provider - A network provider.
* @param {object} config.query - An EthQuery instance.
* @param {Function} config.publishTransaction - Publishes a raw transaction,
*/
2020-11-03 00:41:28 +01:00
constructor(config) {
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
/**
* 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() {
// in order to keep the nonceTracker accurate we block it while updating pending transactions
const nonceGlobalLock = await this.nonceTracker.getGlobalLock();
try {
const pendingTxs = this.getPendingTransactions();
2020-11-03 00:41:28 +01:00
await Promise.all(
pendingTxs.map((txMeta) => this._checkPendingTx(txMeta)),
);
} catch (err) {
2020-11-03 00:41:28 +01:00
log.error(
'PendingTransactionTracker - Error updating pending transactions',
);
log.error(err);
2017-08-04 20:41:35 +02:00
}
nonceGlobalLock.releaseLock();
2017-08-04 20:41:35 +02:00
}
2018-04-13 22:18:45 +02:00
/**
* Resubmits each pending transaction
*
* @param {string} blockNumber - the latest block number in hex
* @fires tx:warning
* @returns {Promise<void>}
*/
2020-11-03 00:41:28 +01:00
async resubmitPendingTxs(blockNumber) {
const pending = this.getPendingTransactions();
if (!pending.length) {
return;
}
for (const txMeta of pending) {
try {
await this._resubmitTx(txMeta, blockNumber);
} catch (err) {
2020-11-03 00:41:28 +01:00
const errorMessage =
err.value?.message?.toLowerCase() || err.message.toLowerCase();
2020-11-03 00:41:28 +01:00
const isKnownTx =
// 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',
) ||
// other
errorMessage.includes('gateway timeout') ||
errorMessage.includes('nonce too low');
// ignore resubmit warnings, return early
if (isKnownTx) {
return;
}
// encountered real error - transition to error state
txMeta.warning = {
error: errorMessage,
message: ERROR_SUBMITTING,
};
this.emit('tx:warning', txMeta, err);
}
}
2017-08-04 20:41:35 +02:00
}
2018-04-13 22:18:45 +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.
*
* @param {object} txMeta - the transaction metadata
* @param {string} latestBlockNumber - the latest block number in hex
* @returns {Promise<string|undefined>} the tx hash if retried
* @fires tx:block-update
* @fires tx:retry
* @private
*/
2020-11-03 00:41:28 +01:00
async _resubmitTx(txMeta, latestBlockNumber) {
if (!txMeta.firstRetryBlockNumber) {
this.emit('tx:block-update', txMeta, latestBlockNumber);
}
2020-11-03 00:41:28 +01:00
const firstRetryBlockNumber =
txMeta.firstRetryBlockNumber || latestBlockNumber;
2020-11-03 00:41:28 +01:00
const txBlockDistance =
Number.parseInt(latestBlockNumber, 16) -
Number.parseInt(firstRetryBlockNumber, 16);
const retryCount = txMeta.retryCount || 0;
// Exponential backoff to limit retries at publishing (capped at ~15 minutes between retries)
if (txBlockDistance < Math.min(50, Math.pow(2, retryCount))) {
return undefined;
}
2017-08-04 20:41:35 +02:00
// Only auto-submit already-signed txs:
if (!('rawTx' in txMeta)) {
return this.approveTransaction(txMeta.id);
}
2017-08-04 20:41:35 +02:00
const { rawTx } = txMeta;
const txHash = await this.publishTransaction(rawTx);
// Increment successful tries:
this.emit('tx:retry', txMeta);
return txHash;
2017-08-04 20:41:35 +02:00
}
2018-04-13 22:18:45 +02:00
/**
* Query the network to see if the given {@code txMeta} has been included in a block
*
* @param {object} txMeta - the transaction metadata
* @returns {Promise<void>}
* @fires tx:confirmed
* @fires tx:dropped
* @fires tx:failed
* @fires tx:warning
* @private
*/
2020-11-03 00:41:28 +01:00
async _checkPendingTx(txMeta) {
const txHash = txMeta.hash;
const txId = txMeta.id;
// Only check submitted txs
if (txMeta.status !== TRANSACTION_STATUSES.SUBMITTED) {
return;
}
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.',
);
noTxHashErr.name = 'NoTxHashError';
this.emit('tx:failed', txId, noTxHashErr);
return;
2017-08-04 20:41:35 +02:00
}
2020-05-01 19:49:29 +02:00
if (await this._checkIfNonceIsTaken(txMeta)) {
this.emit('tx:dropped', txId);
return;
}
2020-05-01 19:49:29 +02:00
try {
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);
this.emit(
'tx:confirmed',
txId,
transactionReceipt,
baseFeePerGas,
blockTimestamp,
);
return;
2020-05-01 19:49:29 +02:00
}
} catch (err) {
2017-08-04 20:41:35 +02:00
txMeta.warning = {
error: err.message,
2017-08-04 20:41:35 +02:00
message: 'There was a problem loading this transaction.',
};
this.emit('tx:warning', txMeta, err);
return;
2020-05-01 19:49:29 +02:00
}
if (await this._checkIfTxWasDropped(txMeta)) {
this.emit('tx:dropped', txId);
2017-08-04 20:41:35 +02:00
}
}
/**
2020-05-01 19:49:29 +02:00
* Checks whether the nonce in the given {@code txMeta} is behind the network nonce
*
* @param {object} txMeta - the transaction metadata
* @returns {Promise<boolean>}
* @private
*/
2020-11-03 00:41:28 +01:00
async _checkIfTxWasDropped(txMeta) {
const {
hash: txHash,
txParams: { nonce, from },
} = txMeta;
const networkNextNonce = await this.query.getTransactionCount(from);
2020-05-01 19:49:29 +02:00
if (parseInt(nonce, 16) >= networkNextNonce.toNumber()) {
return false;
2020-05-01 19:49:29 +02:00
}
if (!this.droppedBlocksBufferByHash.has(txHash)) {
this.droppedBlocksBufferByHash.set(txHash, 0);
2020-05-01 19:49:29 +02:00
}
const currentBlockBuffer = this.droppedBlocksBufferByHash.get(txHash);
2020-05-01 19:49:29 +02:00
if (currentBlockBuffer < this.DROPPED_BUFFER_COUNT) {
this.droppedBlocksBufferByHash.set(txHash, currentBlockBuffer + 1);
return false;
2020-05-01 19:49:29 +02:00
}
this.droppedBlocksBufferByHash.delete(txHash);
return true;
}
2017-08-04 20:41:35 +02:00
2018-04-13 22:18:45 +02:00
/**
* Checks whether the nonce in the given {@code txMeta} is correct against the local set of transactions
*
* @param {object} txMeta - the transaction metadata
* @returns {Promise<boolean>}
* @private
*/
2020-11-03 00:41:28 +01:00
async _checkIfNonceIsTaken(txMeta) {
const address = txMeta.txParams.from;
const completed = this.getCompletedTransactions(address);
return completed.some(
// 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,
);
}
}