396 lines
14 KiB
JavaScript
396 lines
14 KiB
JavaScript
const EventEmitter = require('events')
|
|
const ObservableStore = require('obs-store')
|
|
const ethUtil = require('ethereumjs-util')
|
|
const Transaction = require('ethereumjs-tx')
|
|
const EthQuery = require('ethjs-query')
|
|
const TransactionStateManager = require('../lib/tx-state-manager')
|
|
const TxGasUtil = require('../lib/tx-gas-utils')
|
|
const PendingTransactionTracker = require('../lib/pending-tx-tracker')
|
|
const NonceTracker = require('../lib/nonce-tracker')
|
|
|
|
/*
|
|
Transaction Controller is an aggregate of sub-controllers and trackers
|
|
composing them in a way to be exposed to the metamask controller
|
|
- txStateManager
|
|
responsible for the state of a transaction and
|
|
storing the transaction
|
|
- pendingTxTracker
|
|
watching blocks for transactions to be include
|
|
and emitting confirmed events
|
|
- txGasUtil
|
|
gas calculations and safety buffering
|
|
- nonceTracker
|
|
calculating nonces
|
|
*/
|
|
|
|
module.exports = class TransactionController extends EventEmitter {
|
|
constructor (opts) {
|
|
super()
|
|
this.networkStore = opts.networkStore || new ObservableStore({})
|
|
this.preferencesStore = opts.preferencesStore || new ObservableStore({})
|
|
this.provider = opts.provider
|
|
this.blockTracker = opts.blockTracker
|
|
this.signEthTx = opts.signTransaction
|
|
this.getGasPrice = opts.getGasPrice
|
|
|
|
this.memStore = new ObservableStore({})
|
|
this.query = new EthQuery(this.provider)
|
|
this.txGasUtil = new TxGasUtil(this.provider)
|
|
|
|
this.txStateManager = new TransactionStateManager({
|
|
initState: opts.initState,
|
|
txHistoryLimit: opts.txHistoryLimit,
|
|
getNetwork: this.getNetwork.bind(this),
|
|
})
|
|
|
|
this.txStateManager.getFilteredTxList({
|
|
status: 'unapproved',
|
|
loadingDefaults: true,
|
|
}).forEach((tx) => {
|
|
this.addTxDefaults(tx)
|
|
.then((txMeta) => {
|
|
txMeta.loadingDefaults = false
|
|
this.txStateManager.updateTx(txMeta, 'transactions: gas estimation for tx on boot')
|
|
}).catch((error) => {
|
|
this.txStateManager.setTxStatusFailed(tx.id, error)
|
|
})
|
|
})
|
|
|
|
this.txStateManager.getFilteredTxList({
|
|
status: 'approved',
|
|
}).forEach((txMeta) => {
|
|
const txSignError = new Error('Transaction found as "approved" during boot - possibly stuck during signing')
|
|
this.txStateManager.setTxStatusFailed(txMeta.id, txSignError)
|
|
})
|
|
|
|
|
|
this.store = this.txStateManager.store
|
|
this.txStateManager.on('tx:status-update', this.emit.bind(this, 'tx:status-update'))
|
|
this.nonceTracker = new NonceTracker({
|
|
provider: this.provider,
|
|
getPendingTransactions: this.txStateManager.getPendingTransactions.bind(this.txStateManager),
|
|
getConfirmedTransactions: (address) => {
|
|
return this.txStateManager.getFilteredTxList({
|
|
from: address,
|
|
status: 'confirmed',
|
|
err: undefined,
|
|
})
|
|
},
|
|
})
|
|
|
|
this.pendingTxTracker = new PendingTransactionTracker({
|
|
provider: this.provider,
|
|
nonceTracker: this.nonceTracker,
|
|
publishTransaction: (rawTx) => this.query.sendRawTransaction(rawTx),
|
|
getPendingTransactions: this.txStateManager.getPendingTransactions.bind(this.txStateManager),
|
|
getCompletedTransactions: this.txStateManager.getConfirmedTransactions.bind(this.txStateManager),
|
|
})
|
|
|
|
this.txStateManager.store.subscribe(() => this.emit('update:badge'))
|
|
|
|
this.pendingTxTracker.on('tx:warning', (txMeta) => {
|
|
this.txStateManager.updateTx(txMeta, 'transactions/pending-tx-tracker#event: tx:warning')
|
|
})
|
|
this.pendingTxTracker.on('tx:confirmed', (txId) => this._markNonceDuplicatesDropped(txId))
|
|
this.pendingTxTracker.on('tx:failed', this.txStateManager.setTxStatusFailed.bind(this.txStateManager))
|
|
this.pendingTxTracker.on('tx:block-update', (txMeta, latestBlockNumber) => {
|
|
if (!txMeta.firstRetryBlockNumber) {
|
|
txMeta.firstRetryBlockNumber = latestBlockNumber
|
|
this.txStateManager.updateTx(txMeta, 'transactions/pending-tx-tracker#event: tx:block-update')
|
|
}
|
|
})
|
|
this.pendingTxTracker.on('tx:retry', (txMeta) => {
|
|
if (!('retryCount' in txMeta)) txMeta.retryCount = 0
|
|
txMeta.retryCount++
|
|
this.txStateManager.updateTx(txMeta, 'transactions/pending-tx-tracker#event: tx:retry')
|
|
})
|
|
|
|
this.blockTracker.on('block', this.pendingTxTracker.checkForTxInBlock.bind(this.pendingTxTracker))
|
|
// this is a little messy but until ethstore has been either
|
|
// removed or redone this is to guard against the race condition
|
|
this.blockTracker.on('latest', this.pendingTxTracker.resubmitPendingTxs.bind(this.pendingTxTracker))
|
|
this.blockTracker.on('sync', this.pendingTxTracker.queryPendingTxs.bind(this.pendingTxTracker))
|
|
// memstore is computed from a few different stores
|
|
this._updateMemstore()
|
|
this.txStateManager.store.subscribe(() => this._updateMemstore())
|
|
this.networkStore.subscribe(() => this._updateMemstore())
|
|
this.preferencesStore.subscribe(() => this._updateMemstore())
|
|
}
|
|
|
|
getState () {
|
|
return this.memStore.getState()
|
|
}
|
|
|
|
getNetwork () {
|
|
return this.networkStore.getState()
|
|
}
|
|
|
|
getSelectedAddress () {
|
|
return this.preferencesStore.getState().selectedAddress
|
|
}
|
|
|
|
getUnapprovedTxCount () {
|
|
return Object.keys(this.txStateManager.getUnapprovedTxList()).length
|
|
}
|
|
|
|
getPendingTxCount (account) {
|
|
return this.txStateManager.getPendingTransactions(account).length
|
|
}
|
|
|
|
getFilteredTxList (opts) {
|
|
return this.txStateManager.getFilteredTxList(opts)
|
|
}
|
|
|
|
getChainId () {
|
|
const networkState = this.networkStore.getState()
|
|
const getChainId = parseInt(networkState)
|
|
if (Number.isNaN(getChainId)) {
|
|
return 0
|
|
} else {
|
|
return getChainId
|
|
}
|
|
}
|
|
|
|
wipeTransactions (address) {
|
|
this.txStateManager.wipeTransactions(address)
|
|
}
|
|
|
|
// Adds a tx to the txlist
|
|
addTx (txMeta) {
|
|
this.txStateManager.addTx(txMeta)
|
|
this.emit(`${txMeta.id}:unapproved`, txMeta)
|
|
}
|
|
|
|
async newUnapprovedTransaction (txParams, opts = {}) {
|
|
log.debug(`MetaMaskController newUnapprovedTransaction ${JSON.stringify(txParams)}`)
|
|
const initialTxMeta = await this.addUnapprovedTransaction(txParams)
|
|
initialTxMeta.origin = opts.origin
|
|
this.txStateManager.updateTx(initialTxMeta, '#newUnapprovedTransaction - adding the origin')
|
|
// listen for tx completion (success, fail)
|
|
return new Promise((resolve, reject) => {
|
|
this.txStateManager.once(`${initialTxMeta.id}:finished`, (finishedTxMeta) => {
|
|
switch (finishedTxMeta.status) {
|
|
case 'submitted':
|
|
return resolve(finishedTxMeta.hash)
|
|
case 'rejected':
|
|
return reject(new Error('MetaMask Tx Signature: User denied transaction signature.'))
|
|
case 'failed':
|
|
return reject(new Error(finishedTxMeta.err.message))
|
|
default:
|
|
return reject(new Error(`MetaMask Tx Signature: Unknown problem: ${JSON.stringify(finishedTxMeta.txParams)}`))
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
async addUnapprovedTransaction (txParams) {
|
|
// validate
|
|
const normalizedTxParams = this._normalizeTxParams(txParams)
|
|
this._validateTxParams(normalizedTxParams)
|
|
// construct txMeta
|
|
let txMeta = this.txStateManager.generateTxMeta({ txParams: normalizedTxParams })
|
|
this.addTx(txMeta)
|
|
this.emit('newUnapprovedTx', txMeta)
|
|
// add default tx params
|
|
try {
|
|
txMeta = await this.addTxDefaults(txMeta)
|
|
} catch (error) {
|
|
console.log(error)
|
|
this.txStateManager.setTxStatusFailed(txMeta.id, error)
|
|
throw error
|
|
}
|
|
txMeta.loadingDefaults = false
|
|
// save txMeta
|
|
this.txStateManager.updateTx(txMeta)
|
|
|
|
return txMeta
|
|
}
|
|
|
|
async addTxDefaults (txMeta) {
|
|
const txParams = txMeta.txParams
|
|
// ensure value
|
|
txMeta.gasPriceSpecified = Boolean(txParams.gasPrice)
|
|
let gasPrice = txParams.gasPrice
|
|
if (!gasPrice) {
|
|
gasPrice = this.getGasPrice ? this.getGasPrice() : await this.query.gasPrice()
|
|
}
|
|
txParams.gasPrice = ethUtil.addHexPrefix(gasPrice.toString(16))
|
|
txParams.value = txParams.value || '0x0'
|
|
// set gasLimit
|
|
return await this.txGasUtil.analyzeGasUsage(txMeta)
|
|
}
|
|
|
|
async retryTransaction (originalTxId) {
|
|
const originalTxMeta = this.txStateManager.getTx(originalTxId)
|
|
const lastGasPrice = originalTxMeta.txParams.gasPrice
|
|
const txMeta = this.txStateManager.generateTxMeta({
|
|
txParams: originalTxMeta.txParams,
|
|
lastGasPrice,
|
|
loadingDefaults: false,
|
|
})
|
|
this.addTx(txMeta)
|
|
this.emit('newUnapprovedTx', txMeta)
|
|
return txMeta
|
|
}
|
|
|
|
async updateTransaction (txMeta) {
|
|
this.txStateManager.updateTx(txMeta, 'confTx: user updated transaction')
|
|
}
|
|
|
|
async updateAndApproveTransaction (txMeta) {
|
|
this.txStateManager.updateTx(txMeta, 'confTx: user approved transaction')
|
|
await this.approveTransaction(txMeta.id)
|
|
}
|
|
|
|
async approveTransaction (txId) {
|
|
let nonceLock
|
|
try {
|
|
// approve
|
|
this.txStateManager.setTxStatusApproved(txId)
|
|
// get next nonce
|
|
const txMeta = this.txStateManager.getTx(txId)
|
|
const fromAddress = txMeta.txParams.from
|
|
// wait for a nonce
|
|
nonceLock = await this.nonceTracker.getNonceLock(fromAddress)
|
|
// add nonce to txParams
|
|
// if txMeta has lastGasPrice then it is a retry at same nonce with higher
|
|
// gas price transaction and their for the nonce should not be calculated
|
|
const nonce = txMeta.lastGasPrice ? txMeta.txParams.nonce : nonceLock.nextNonce
|
|
txMeta.txParams.nonce = ethUtil.addHexPrefix(nonce.toString(16))
|
|
// add nonce debugging information to txMeta
|
|
txMeta.nonceDetails = nonceLock.nonceDetails
|
|
this.txStateManager.updateTx(txMeta, 'transactions#approveTransaction')
|
|
// sign transaction
|
|
const rawTx = await this.signTransaction(txId)
|
|
await this.publishTransaction(txId, rawTx)
|
|
// must set transaction to submitted/failed before releasing lock
|
|
nonceLock.releaseLock()
|
|
} catch (err) {
|
|
this.txStateManager.setTxStatusFailed(txId, err)
|
|
// must set transaction to submitted/failed before releasing lock
|
|
if (nonceLock) nonceLock.releaseLock()
|
|
// continue with error chain
|
|
throw err
|
|
}
|
|
}
|
|
|
|
async signTransaction (txId) {
|
|
const txMeta = this.txStateManager.getTx(txId)
|
|
// add network/chain id
|
|
const chainId = this.getChainId()
|
|
const txParams = Object.assign({}, txMeta.txParams, { chainId })
|
|
// sign tx
|
|
const fromAddress = txParams.from
|
|
const ethTx = new Transaction(txParams)
|
|
await this.signEthTx(ethTx, fromAddress)
|
|
// set state to signed
|
|
this.txStateManager.setTxStatusSigned(txMeta.id)
|
|
const rawTx = ethUtil.bufferToHex(ethTx.serialize())
|
|
return rawTx
|
|
}
|
|
|
|
async publishTransaction (txId, rawTx) {
|
|
const txMeta = this.txStateManager.getTx(txId)
|
|
txMeta.rawTx = rawTx
|
|
this.txStateManager.updateTx(txMeta, 'transactions#publishTransaction')
|
|
const txHash = await this.query.sendRawTransaction(rawTx)
|
|
this.setTxHash(txId, txHash)
|
|
this.txStateManager.setTxStatusSubmitted(txId)
|
|
}
|
|
|
|
async cancelTransaction (txId) {
|
|
this.txStateManager.setTxStatusRejected(txId)
|
|
}
|
|
|
|
// receives a txHash records the tx as signed
|
|
setTxHash (txId, txHash) {
|
|
// Add the tx hash to the persisted meta-tx object
|
|
const txMeta = this.txStateManager.getTx(txId)
|
|
txMeta.hash = txHash
|
|
this.txStateManager.updateTx(txMeta, 'transactions#setTxHash')
|
|
}
|
|
|
|
//
|
|
// PRIVATE METHODS
|
|
//
|
|
|
|
_normalizeTxParams (txParams) {
|
|
// functions that handle normalizing of that key in txParams
|
|
const whiteList = {
|
|
from: from => ethUtil.addHexPrefix(from).toLowerCase(),
|
|
to: to => ethUtil.addHexPrefix(txParams.to).toLowerCase(),
|
|
nonce: nonce => ethUtil.addHexPrefix(nonce),
|
|
value: value => ethUtil.addHexPrefix(value),
|
|
data: data => ethUtil.addHexPrefix(data),
|
|
gas: gas => ethUtil.addHexPrefix(gas),
|
|
gasPrice: gasPrice => ethUtil.addHexPrefix(gasPrice),
|
|
}
|
|
|
|
// apply only keys in the whiteList
|
|
const normalizedTxParams = {}
|
|
Object.keys(whiteList).forEach((key) => {
|
|
if (txParams[key]) normalizedTxParams[key] = whiteList[key](txParams[key])
|
|
})
|
|
|
|
return normalizedTxParams
|
|
}
|
|
|
|
_validateTxParams (txParams) {
|
|
this._validateFrom(txParams)
|
|
this._validateRecipient(txParams)
|
|
if ('value' in txParams) {
|
|
const value = txParams.value.toString()
|
|
if (value.includes('-')) {
|
|
throw new Error(`Invalid transaction value of ${txParams.value} not a positive number.`)
|
|
}
|
|
|
|
if (value.includes('.')) {
|
|
throw new Error(`Invalid transaction value of ${txParams.value} number must be in wei`)
|
|
}
|
|
}
|
|
}
|
|
|
|
_validateFrom (txParams) {
|
|
if ( !(typeof txParams.from === 'string') ) throw new Error(`Invalid from address ${txParams.from} not a string`)
|
|
if (!ethUtil.isValidAddress(txParams.from)) throw new Error('Invalid from address')
|
|
}
|
|
|
|
_validateRecipient (txParams) {
|
|
if (txParams.to === '0x' || txParams.to === null ) {
|
|
if (txParams.data) {
|
|
delete txParams.to
|
|
} else {
|
|
throw new Error('Invalid recipient address')
|
|
}
|
|
} else if ( txParams.to !== undefined && !ethUtil.isValidAddress(txParams.to) ) {
|
|
throw new Error('Invalid recipient address')
|
|
}
|
|
return txParams
|
|
}
|
|
|
|
_markNonceDuplicatesDropped (txId) {
|
|
this.txStateManager.setTxStatusConfirmed(txId)
|
|
// get the confirmed transactions nonce and from address
|
|
const txMeta = this.txStateManager.getTx(txId)
|
|
const { nonce, from } = txMeta.txParams
|
|
const sameNonceTxs = this.txStateManager.getFilteredTxList({nonce, from})
|
|
if (!sameNonceTxs.length) return
|
|
// mark all same nonce transactions as dropped and give i a replacedBy hash
|
|
sameNonceTxs.forEach((otherTxMeta) => {
|
|
if (otherTxMeta.id === txId) return
|
|
otherTxMeta.replacedBy = txMeta.hash
|
|
this.txStateManager.updateTx(txMeta, 'transactions/pending-tx-tracker#event: tx:confirmed reference to confirmed txHash with same nonce')
|
|
this.txStateManager.setTxStatusDropped(otherTxMeta.id)
|
|
})
|
|
}
|
|
|
|
_updateMemstore () {
|
|
const unapprovedTxs = this.txStateManager.getUnapprovedTxList()
|
|
const selectedAddressTxList = this.txStateManager.getFilteredTxList({
|
|
from: this.getSelectedAddress(),
|
|
metamaskNetworkId: this.getNetwork(),
|
|
})
|
|
this.memStore.updateState({ unapprovedTxs, selectedAddressTxList })
|
|
}
|
|
}
|