1
0
mirror of https://github.com/kremalicious/metamask-extension.git synced 2024-12-12 12:47:14 +01:00
metamask-extension/app/scripts/controllers/transactions/pending-tx-tracker.js
Dan J Miller aaa15cbe03
Add support for EIP1559 transactions to transaction breakdown (#11622)
* Add support for EIP1559 transactions to transaction breakdown

* Use userPreferencedCurrencyDisplay for effective gas price in transaction breakdown

* Hide eip1559 gas properties in transaction breakdown on non-1559 networks

* Add comment explaining gasPrice and effectiveGasPrice usage in transaction breakdown container.
2021-07-28 15:00:34 -02:30

269 lines
8.3 KiB
JavaScript

import EventEmitter from 'safe-event-emitter';
import log from 'loglevel';
import EthQuery from 'ethjs-query';
import { TRANSACTION_STATUSES } from '../../../../shared/constants/transaction';
/**
Event emitter utility class for tracking the transactions as they<br>
go from a pending state to a confirmed (mined in a block) state<br>
<br>
As well as continues broadcast while in the pending state
<br>
@param {Object} config - non optional configuration object consists of:
@param {Object} config.provider - A network provider.
@param {Object} config.nonceTracker - see nonce tracker
@param {Function} config.getPendingTransactions - a function for getting an array of transactions,
@param {Function} config.publishTransaction - a async function for publishing raw transactions,
@class
*/
export default class PendingTransactionTracker extends EventEmitter {
/**
* 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;
/**
* A map of transaction hashes to the number of blocks we've seen
* since first considering it dropped
*
* @type {Map<String, number>}
*/
droppedBlocksBufferByHash = new Map();
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;
}
/**
checks the network for signed txs and releases the nonce global lock if it is
*/
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();
await Promise.all(
pendingTxs.map((txMeta) => this._checkPendingTx(txMeta)),
);
} catch (err) {
log.error(
'PendingTransactionTracker - Error updating pending transactions',
);
log.error(err);
}
nonceGlobalLock.releaseLock();
}
/**
* Resubmits each pending transaction
* @param {string} blockNumber - the latest block number in hex
* @emits tx:warning
* @returns {Promise<void>}
*/
async resubmitPendingTxs(blockNumber) {
const pending = this.getPendingTransactions();
if (!pending.length) {
return;
}
for (const txMeta of pending) {
try {
await this._resubmitTx(txMeta, blockNumber);
} catch (err) {
const errorMessage =
err.value?.message?.toLowerCase() || err.message.toLowerCase();
const isKnownTx =
// geth
errorMessage.includes('replacement transaction underpriced') ||
errorMessage.includes('known transaction') ||
// parity
errorMessage.includes('gas price too low to replace') ||
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: 'There was an error when resubmitting this transaction.',
};
this.emit('tx:warning', txMeta, err);
}
}
}
/**
* 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
* @emits tx:block-update
* @emits tx:retry
* @private
*/
async _resubmitTx(txMeta, latestBlockNumber) {
if (!txMeta.firstRetryBlockNumber) {
this.emit('tx:block-update', txMeta, latestBlockNumber);
}
const firstRetryBlockNumber =
txMeta.firstRetryBlockNumber || latestBlockNumber;
const txBlockDistance =
Number.parseInt(latestBlockNumber, 16) -
Number.parseInt(firstRetryBlockNumber, 16);
const retryCount = txMeta.retryCount || 0;
// Exponential backoff to limit retries at publishing
if (txBlockDistance <= Math.pow(2, retryCount) - 1) {
return undefined;
}
// Only auto-submit already-signed txs:
if (!('rawTx' in txMeta)) {
return this.approveTransaction(txMeta.id);
}
const { rawTx } = txMeta;
const txHash = await this.publishTransaction(rawTx);
// Increment successful tries:
this.emit('tx:retry', txMeta);
return txHash;
}
/**
* 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>}
* @emits tx:confirmed
* @emits tx:dropped
* @emits tx:failed
* @emits tx:warning
* @private
*/
async _checkPendingTx(txMeta) {
const txHash = txMeta.hash;
const txId = txMeta.id;
// Only check submitted txs
if (txMeta.status !== TRANSACTION_STATUSES.SUBMITTED) {
return;
}
// extra check in case there was an uncaught error during the
// signature and submission process
if (!txHash) {
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;
}
if (await this._checkIfNonceIsTaken(txMeta)) {
this.emit('tx:dropped', txId);
return;
}
try {
const transactionReceipt = await this.query.getTransactionReceipt(txHash);
if (transactionReceipt?.blockNumber) {
const { baseFeePerGas } = await this.query.getBlockByHash(
transactionReceipt?.blockHash,
false,
);
this.emit('tx:confirmed', txId, transactionReceipt, baseFeePerGas);
return;
}
} catch (err) {
txMeta.warning = {
error: err.message,
message: 'There was a problem loading this transaction.',
};
this.emit('tx:warning', txMeta, err);
return;
}
if (await this._checkIfTxWasDropped(txMeta)) {
this.emit('tx:dropped', txId);
}
}
/**
* Checks whether the nonce in the given {@code txMeta} is behind the network nonce
*
* @param {Object} txMeta - the transaction metadata
* @returns {Promise<boolean>}
* @private
*/
async _checkIfTxWasDropped(txMeta) {
const {
hash: txHash,
txParams: { nonce, from },
} = txMeta;
const networkNextNonce = await this.query.getTransactionCount(from);
if (parseInt(nonce, 16) >= networkNextNonce.toNumber()) {
return false;
}
if (!this.droppedBlocksBufferByHash.has(txHash)) {
this.droppedBlocksBufferByHash.set(txHash, 0);
}
const currentBlockBuffer = this.droppedBlocksBufferByHash.get(txHash);
if (currentBlockBuffer < this.DROPPED_BUFFER_COUNT) {
this.droppedBlocksBufferByHash.set(txHash, currentBlockBuffer + 1);
return false;
}
this.droppedBlocksBufferByHash.delete(txHash);
return true;
}
/**
* 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
*/
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
(other) =>
!(other.id === txMeta.id) &&
other.txParams.nonce === txMeta.txParams.nonce,
);
}
}