391 lines
11 KiB
JavaScript
391 lines
11 KiB
JavaScript
const EventEmitter = require('events')
|
|
const async = require('async')
|
|
const extend = require('xtend')
|
|
const Semaphore = require('semaphore')
|
|
const ObservableStore = require('obs-store')
|
|
const ethUtil = require('ethereumjs-util')
|
|
const BN = require('ethereumjs-util').BN
|
|
const TxProviderUtil = require('./lib/tx-utils')
|
|
const createId = require('./lib/random-id')
|
|
|
|
module.exports = class TransactionManager extends EventEmitter {
|
|
constructor (opts) {
|
|
super()
|
|
this.store = new ObservableStore(extend({
|
|
transactions: [],
|
|
gasMultiplier: 1,
|
|
}, opts.initState))
|
|
this.memStore = new ObservableStore({})
|
|
this.networkStore = opts.networkStore || new ObservableStore({})
|
|
this.preferencesStore = opts.preferencesStore || new ObservableStore({})
|
|
this.txHistoryLimit = opts.txHistoryLimit
|
|
this.provider = opts.provider
|
|
this.blockTracker = opts.blockTracker
|
|
this.txProviderUtils = new TxProviderUtil(this.provider)
|
|
this.blockTracker.on('block', this.checkForTxInBlock.bind(this))
|
|
this.signEthTx = opts.signTransaction
|
|
this.nonceLock = Semaphore(1)
|
|
|
|
// memstore is computed from a few different stores
|
|
this._updateMemstore()
|
|
this.store.subscribe(() => this._updateMemstore() )
|
|
this.networkStore.subscribe(() => this._updateMemstore() )
|
|
this.preferencesStore.subscribe(() => this._updateMemstore() )
|
|
}
|
|
|
|
getState () {
|
|
return this.memStore.getState()
|
|
}
|
|
|
|
getNetwork () {
|
|
return this.networkStore.getState().network
|
|
}
|
|
|
|
getSelectedAddress () {
|
|
return this.preferencesStore.getState().selectedAddress
|
|
}
|
|
|
|
// Returns the tx list
|
|
getTxList () {
|
|
let network = this.getNetwork()
|
|
let fullTxList = this.store.getState().transactions
|
|
return fullTxList.filter(txMeta => txMeta.metamaskNetworkId === network)
|
|
}
|
|
|
|
getGasMultiplier () {
|
|
return this.store.getState().gasMultiplier
|
|
}
|
|
|
|
setGasMultiplier (gasMultiplier) {
|
|
return this.store.updateState({ gasMultiplier })
|
|
}
|
|
|
|
// Adds a tx to the txlist
|
|
addTx (txMeta) {
|
|
var txList = this.getTxList()
|
|
var txHistoryLimit = this.txHistoryLimit
|
|
|
|
// checks if the length of th tx history is
|
|
// longer then desired persistence limit
|
|
// and then if it is removes only confirmed
|
|
// or rejected tx's.
|
|
// not tx's that are pending or unapproved
|
|
if (txList.length > txHistoryLimit - 1) {
|
|
var index = txList.findIndex((metaTx) => metaTx.status === 'confirmed' || metaTx.status === 'rejected')
|
|
txList.splice(index, 1)
|
|
}
|
|
txList.push(txMeta)
|
|
|
|
this._saveTxList(txList)
|
|
this.once(`${txMeta.id}:signed`, function (txId) {
|
|
this.removeAllListeners(`${txMeta.id}:rejected`)
|
|
})
|
|
this.once(`${txMeta.id}:rejected`, function (txId) {
|
|
this.removeAllListeners(`${txMeta.id}:signed`)
|
|
})
|
|
|
|
this.emit('updateBadge')
|
|
this.emit(`${txMeta.id}:unapproved`, txMeta)
|
|
}
|
|
|
|
// gets tx by Id and returns it
|
|
getTx (txId, cb) {
|
|
var txList = this.getTxList()
|
|
var txMeta = txList.find(txData => txData.id === txId)
|
|
return cb ? cb(txMeta) : txMeta
|
|
}
|
|
|
|
//
|
|
updateTx (txMeta) {
|
|
var txId = txMeta.id
|
|
var txList = this.getTxList()
|
|
var index = txList.findIndex(txData => txData.id === txId)
|
|
txList[index] = txMeta
|
|
this._saveTxList(txList)
|
|
this.emit('update')
|
|
}
|
|
|
|
get unapprovedTxCount () {
|
|
return Object.keys(this.getUnapprovedTxList()).length
|
|
}
|
|
|
|
get pendingTxCount () {
|
|
return this.getTxsByMetaData('status', 'signed').length
|
|
}
|
|
|
|
addUnapprovedTransaction (txParams, done) {
|
|
let txMeta
|
|
async.waterfall([
|
|
// validate
|
|
(cb) => this.txProviderUtils.validateTxParams(txParams, cb),
|
|
// prepare txMeta
|
|
(cb) => {
|
|
// create txMeta obj with parameters and meta data
|
|
let time = (new Date()).getTime()
|
|
let txId = createId()
|
|
txParams.metamaskId = txId
|
|
txParams.metamaskNetworkId = this.getNetwork()
|
|
txMeta = {
|
|
id: txId,
|
|
time: time,
|
|
status: 'unapproved',
|
|
gasMultiplier: this.getGasMultiplier(),
|
|
metamaskNetworkId: this.getNetwork(),
|
|
txParams: txParams,
|
|
}
|
|
// calculate metadata for tx
|
|
this.txProviderUtils.analyzeGasUsage(txMeta, cb)
|
|
},
|
|
// save txMeta
|
|
(cb) => {
|
|
this.addTx(txMeta)
|
|
this.setMaxTxCostAndFee(txMeta)
|
|
cb(null, txMeta)
|
|
},
|
|
], done)
|
|
}
|
|
|
|
setMaxTxCostAndFee (txMeta) {
|
|
var txParams = txMeta.txParams
|
|
var gasMultiplier = txMeta.gasMultiplier
|
|
var gasCost = new BN(ethUtil.stripHexPrefix(txParams.gas || txMeta.estimatedGas), 16)
|
|
var gasPrice = new BN(ethUtil.stripHexPrefix(txParams.gasPrice || '0x4a817c800'), 16)
|
|
gasPrice = gasPrice.mul(new BN(gasMultiplier * 100), 10).div(new BN(100, 10))
|
|
var txFee = gasCost.mul(gasPrice)
|
|
var txValue = new BN(ethUtil.stripHexPrefix(txParams.value || '0x0'), 16)
|
|
var maxCost = txValue.add(txFee)
|
|
txMeta.txFee = txFee
|
|
txMeta.txValue = txValue
|
|
txMeta.maxCost = maxCost
|
|
this.updateTx(txMeta)
|
|
}
|
|
|
|
getUnapprovedTxList () {
|
|
var txList = this.getTxList()
|
|
return txList.filter((txMeta) => txMeta.status === 'unapproved')
|
|
.reduce((result, tx) => {
|
|
result[tx.id] = tx
|
|
return result
|
|
}, {})
|
|
}
|
|
|
|
approveTransaction (txId, cb = warn) {
|
|
const self = this
|
|
// approve
|
|
self.setTxStatusApproved(txId)
|
|
// only allow one tx at a time for atomic nonce usage
|
|
self.nonceLock.take(() => {
|
|
// begin signature process
|
|
async.waterfall([
|
|
(cb) => self.fillInTxParams(txId, cb),
|
|
(cb) => self.signTransaction(txId, cb),
|
|
(rawTx, cb) => self.publishTransaction(txId, rawTx, cb),
|
|
], (err) => {
|
|
self.nonceLock.leave()
|
|
if (err) {
|
|
this.setTxStatusFailed(txId)
|
|
return cb(err)
|
|
}
|
|
cb()
|
|
})
|
|
})
|
|
}
|
|
|
|
cancelTransaction (txId, cb = warn) {
|
|
this.setTxStatusRejected(txId)
|
|
cb()
|
|
}
|
|
|
|
fillInTxParams (txId, cb) {
|
|
let txMeta = this.getTx(txId)
|
|
this.txProviderUtils.fillInTxParams(txMeta.txParams, (err) => {
|
|
if (err) return cb(err)
|
|
this.updateTx(txMeta)
|
|
cb()
|
|
})
|
|
}
|
|
|
|
signTransaction (txId, cb) {
|
|
let txMeta = this.getTx(txId)
|
|
let txParams = txMeta.txParams
|
|
let fromAddress = txParams.from
|
|
let ethTx = this.txProviderUtils.buildEthTxFromParams(txParams, txMeta.gasMultiplier)
|
|
this.signEthTx(ethTx, fromAddress).then(() => {
|
|
this.setTxStatusSigned(txMeta.id)
|
|
cb(null, ethUtil.bufferToHex(ethTx.serialize()))
|
|
}).catch((err) => {
|
|
cb(err)
|
|
})
|
|
}
|
|
|
|
publishTransaction (txId, rawTx, cb) {
|
|
this.txProviderUtils.publishTransaction(rawTx, (err, txHash) => {
|
|
if (err) return cb(err)
|
|
this.setTxHash(txId, txHash)
|
|
this.setTxStatusSubmitted(txId)
|
|
cb()
|
|
})
|
|
}
|
|
|
|
// receives a txHash records the tx as signed
|
|
setTxHash (txId, txHash) {
|
|
// Add the tx hash to the persisted meta-tx object
|
|
let txMeta = this.getTx(txId)
|
|
txMeta.hash = txHash
|
|
this.updateTx(txMeta)
|
|
}
|
|
|
|
/*
|
|
Takes an object of fields to search for eg:
|
|
var thingsToLookFor = {
|
|
to: '0x0..',
|
|
from: '0x0..',
|
|
status: 'signed',
|
|
}
|
|
and returns a list of tx with all
|
|
options matching
|
|
|
|
this is for things like filtering a the tx list
|
|
for only tx's from 1 account
|
|
or for filltering for all txs from one account
|
|
and that have been 'confirmed'
|
|
*/
|
|
getFilteredTxList (opts) {
|
|
var filteredTxList
|
|
Object.keys(opts).forEach((key) => {
|
|
filteredTxList = this.getTxsByMetaData(key, opts[key], filteredTxList)
|
|
})
|
|
return filteredTxList
|
|
}
|
|
|
|
getTxsByMetaData (key, value, txList = this.getTxList()) {
|
|
return txList.filter((txMeta) => {
|
|
if (txMeta.txParams[key]) {
|
|
return txMeta.txParams[key] === value
|
|
} else {
|
|
return txMeta[key] === value
|
|
}
|
|
})
|
|
}
|
|
|
|
// STATUS METHODS
|
|
// get::set status
|
|
|
|
// should return the status of the tx.
|
|
getTxStatus (txId) {
|
|
const txMeta = this.getTx(txId)
|
|
return txMeta.status
|
|
}
|
|
|
|
// should update the status of the tx to 'rejected'.
|
|
setTxStatusRejected (txId) {
|
|
this._setTxStatus(txId, 'rejected')
|
|
}
|
|
|
|
// should update the status of the tx to 'approved'.
|
|
setTxStatusApproved (txId) {
|
|
this._setTxStatus(txId, 'approved')
|
|
}
|
|
|
|
// should update the status of the tx to 'signed'.
|
|
setTxStatusSigned (txId) {
|
|
this._setTxStatus(txId, 'signed')
|
|
}
|
|
|
|
// should update the status of the tx to 'submitted'.
|
|
setTxStatusSubmitted (txId) {
|
|
this._setTxStatus(txId, 'submitted')
|
|
}
|
|
|
|
// should update the status of the tx to 'confirmed'.
|
|
setTxStatusConfirmed (txId) {
|
|
this._setTxStatus(txId, 'confirmed')
|
|
}
|
|
|
|
setTxStatusFailed (txId) {
|
|
this._setTxStatus(txId, 'failed')
|
|
}
|
|
|
|
// merges txParams obj onto txData.txParams
|
|
// use extend to ensure that all fields are filled
|
|
updateTxParams (txId, txParams) {
|
|
var txMeta = this.getTx(txId)
|
|
txMeta.txParams = extend(txMeta.txParams, txParams)
|
|
this.updateTx(txMeta)
|
|
}
|
|
|
|
// checks if a signed tx is in a block and
|
|
// if included sets the tx status as 'confirmed'
|
|
checkForTxInBlock () {
|
|
var signedTxList = this.getFilteredTxList({status: 'submitted'})
|
|
if (!signedTxList.length) return
|
|
signedTxList.forEach((txMeta) => {
|
|
var txHash = txMeta.hash
|
|
var txId = txMeta.id
|
|
if (!txHash) {
|
|
txMeta.err = {
|
|
errCode: 'No hash was provided',
|
|
message: 'We had an error while submitting this transaction, please try again.',
|
|
}
|
|
this.updateTx(txMeta)
|
|
return this.setTxStatusFailed(txId)
|
|
}
|
|
this.txProviderUtils.query.getTransactionByHash(txHash, (err, txParams) => {
|
|
if (err || !txParams) {
|
|
if (!txParams) return
|
|
txMeta.err = {
|
|
isWarning: true,
|
|
errorCode: err,
|
|
message: 'There was a problem loading this transaction.',
|
|
}
|
|
this.updateTx(txMeta)
|
|
return console.error(err)
|
|
}
|
|
if (txParams.blockNumber) {
|
|
this.setTxStatusConfirmed(txId)
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
// PRIVATE METHODS
|
|
|
|
// Should find the tx in the tx list and
|
|
// update it.
|
|
// should set the status in txData
|
|
// - `'unapproved'` the user has not responded
|
|
// - `'rejected'` the user has responded no!
|
|
// - `'approved'` the user has approved the tx
|
|
// - `'signed'` the tx is signed
|
|
// - `'submitted'` the tx is sent to a server
|
|
// - `'confirmed'` the tx has been included in a block.
|
|
_setTxStatus (txId, status) {
|
|
var txMeta = this.getTx(txId)
|
|
txMeta.status = status
|
|
this.emit(`${txMeta.id}:${status}`, txId)
|
|
if (status === 'submitted' || status === 'rejected') {
|
|
this.emit(`${txMeta.id}:finished`, status)
|
|
}
|
|
this.updateTx(txMeta)
|
|
this.emit('updateBadge')
|
|
}
|
|
|
|
// Saves the new/updated txList.
|
|
// Function is intended only for internal use
|
|
_saveTxList (transactions) {
|
|
this.store.updateState({ transactions })
|
|
}
|
|
|
|
_updateMemstore () {
|
|
const unapprovedTxs = this.getUnapprovedTxList()
|
|
const selectedAddressTxList = this.getFilteredTxList({
|
|
from: this.getSelectedAddress(),
|
|
metamaskNetworkId: this.getNetwork(),
|
|
})
|
|
this.memStore.updateState({ unapprovedTxs, selectedAddressTxList })
|
|
}
|
|
}
|
|
|
|
|
|
const warn = () => console.warn('warn was used no cb provided')
|