From 2d7c3c2b00a698b19ac015624154c3c1cd2619b2 Mon Sep 17 00:00:00 2001
From: frankiebee <frankie.diamond@gmail.com>
Date: Fri, 6 Apr 2018 11:07:20 -0700
Subject: meta - transactions - create a transactions dir in controller and
 move relevant files into it

---
 app/scripts/controllers/transactions/index.js | 341 ++++++++++++++++++++++++++
 1 file changed, 341 insertions(+)
 create mode 100644 app/scripts/controllers/transactions/index.js

(limited to 'app/scripts/controllers/transactions/index.js')

diff --git a/app/scripts/controllers/transactions/index.js b/app/scripts/controllers/transactions/index.js
new file mode 100644
index 000000000..6f66e3a1e
--- /dev/null
+++ b/app/scripts/controllers/transactions/index.js
@@ -0,0 +1,341 @@
+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('./tx-state-manager')
+const TxGasUtil = require('./tx-gas-utils')
+const PendingTransactionTracker = require('./pending-tx-tracker')
+const NonceTracker = require('./nonce-tracker')
+const txUtils = require('./lib/util')
+/*
+  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 = txUtils.normalizeTxParams(txParams)
+    txUtils.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
+//
+
+  _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 })
+  }
+}
-- 
cgit 


From 3aaa28531e1b05a93a68d8016d1648191cdc9696 Mon Sep 17 00:00:00 2001
From: frankiebee <frankie.diamond@gmail.com>
Date: Thu, 12 Apr 2018 12:24:16 -0700
Subject: transactions - code cleanup

---
 app/scripts/controllers/transactions/index.js | 113 +++++++++++++-------------
 1 file changed, 57 insertions(+), 56 deletions(-)

(limited to 'app/scripts/controllers/transactions/index.js')

diff --git a/app/scripts/controllers/transactions/index.js b/app/scripts/controllers/transactions/index.js
index 6f66e3a1e..ca6c3923e 100644
--- a/app/scripts/controllers/transactions/index.js
+++ b/app/scripts/controllers/transactions/index.js
@@ -43,39 +43,13 @@ module.exports = class TransactionController extends EventEmitter {
       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._onBootCleanUp()
 
     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,
-        })
-      },
+      getConfirmedTransactions: this.txStateManager.getConfirmedTransactions.bind(this.txStateManager),
     })
 
     this.pendingTxTracker = new PendingTransactionTracker({
@@ -87,29 +61,7 @@ module.exports = class TransactionController extends EventEmitter {
     })
 
     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))
+    this._setupListners()
     // memstore is computed from a few different stores
     this._updateMemstore()
     this.txStateManager.store.subscribe(() => this._updateMemstore())
@@ -151,16 +103,16 @@ module.exports = class TransactionController extends EventEmitter {
     }
   }
 
-  wipeTransactions (address) {
-    this.txStateManager.wipeTransactions(address)
-  }
-
-  // Adds a tx to the txlist
+// Adds a tx to the txlist
   addTx (txMeta) {
     this.txStateManager.addTx(txMeta)
     this.emit(`${txMeta.id}:unapproved`, txMeta)
   }
 
+  wipeTransactions (address) {
+    this.txStateManager.wipeTransactions(address)
+  }
+
   async newUnapprovedTransaction (txParams, opts = {}) {
     log.debug(`MetaMaskController newUnapprovedTransaction ${JSON.stringify(txParams)}`)
     const initialTxMeta = await this.addUnapprovedTransaction(txParams)
@@ -314,6 +266,55 @@ module.exports = class TransactionController extends EventEmitter {
 //           PRIVATE METHODS
 //
 
+  _onBootCleanUp () {
+    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)
+    })
+  }
+
+  _setupListners () {
+    this.txStateManager.on('tx:status-update', this.emit.bind(this, 'tx:status-update'))
+    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))
+
+  }
+
   _markNonceDuplicatesDropped (txId) {
     this.txStateManager.setTxStatusConfirmed(txId)
     // get the confirmed transactions nonce and from address
-- 
cgit 


From 88f4212363601b2bb3778f4090235a0a0740b4c9 Mon Sep 17 00:00:00 2001
From: frankiebee <frankie.diamond@gmail.com>
Date: Fri, 13 Apr 2018 12:38:07 -0700
Subject: meta - transactions - code clean up and jsDoc

---
 app/scripts/controllers/transactions/index.js | 150 +++++++++++++++++++-------
 1 file changed, 109 insertions(+), 41 deletions(-)

(limited to 'app/scripts/controllers/transactions/index.js')

diff --git a/app/scripts/controllers/transactions/index.js b/app/scripts/controllers/transactions/index.js
index ca6c3923e..ca83941fc 100644
--- a/app/scripts/controllers/transactions/index.js
+++ b/app/scripts/controllers/transactions/index.js
@@ -8,22 +8,37 @@ const TxGasUtil = require('./tx-gas-utils')
 const PendingTransactionTracker = require('./pending-tx-tracker')
 const NonceTracker = require('./nonce-tracker')
 const txUtils = require('./lib/util')
-/*
+
+module.exports = TransactionController
+
+/**
   Transaction Controller is an aggregate of sub-controllers and trackers
   composing them in a way to be exposed to the metamask controller
-    - txStateManager
+    <br>- txStateManager
       responsible for the state of a transaction and
       storing the transaction
-    - pendingTxTracker
+    <br>- pendingTxTracker
       watching blocks for transactions to be include
       and emitting confirmed events
-    - txGasUtil
+    <br>- txGasUtil
       gas calculations and safety buffering
-    - nonceTracker
+    <br>- nonceTracker
       calculating nonces
+
+
+@param {object} opts -
+  - initState, initial transaction list default is an empty array<br>
+  - networkStore, an observable store for network number<br>
+  - blockTracker,<br>
+  - provider,<br>
+  - signTransaction, function the signs an ethereumjs-tx<br>
+  - getGasPrice, optional gas price calculator<br>
+  - txHistoryLimit, number *optional* for limiting how many transactions are in state <br>
+  - preferencesStore,
+@class
 */
 
-module.exports = class TransactionController extends EventEmitter {
+class TransactionController extends EventEmitter {
   constructor (opts) {
     super()
     this.networkStore = opts.networkStore || new ObservableStore({})
@@ -42,7 +57,7 @@ module.exports = class TransactionController extends EventEmitter {
       txHistoryLimit: opts.txHistoryLimit,
       getNetwork: this.getNetwork.bind(this),
     })
-
+    this._mapMethods()
     this._onBootCleanUp()
 
     this.store = this.txStateManager.store
@@ -68,31 +83,7 @@ module.exports = class TransactionController extends EventEmitter {
     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)
-  }
-
+  /** @returns {number} the chainId*/
   getChainId () {
     const networkState = this.networkStore.getState()
     const getChainId = parseInt(networkState)
@@ -103,16 +94,27 @@ module.exports = class TransactionController extends EventEmitter {
     }
   }
 
-// Adds a tx to the txlist
+/** Adds a tx to the txlist */
   addTx (txMeta) {
     this.txStateManager.addTx(txMeta)
     this.emit(`${txMeta.id}:unapproved`, txMeta)
   }
 
+/**
+  wipes the transactions for a given account
+  @param address {string} - hex string of the from address for txs being removed
+*/
   wipeTransactions (address) {
     this.txStateManager.wipeTransactions(address)
   }
 
+/**
+add a new unapproved transaction to the pipeline
+@returns {promise}
+@param txParams {object} - txParams for the transaction
+@param opts {object} - with the key origin to put the origin on the txMeta
+
+*/
   async newUnapprovedTransaction (txParams, opts = {}) {
     log.debug(`MetaMaskController newUnapprovedTransaction ${JSON.stringify(txParams)}`)
     const initialTxMeta = await this.addUnapprovedTransaction(txParams)
@@ -135,6 +137,13 @@ module.exports = class TransactionController extends EventEmitter {
     })
   }
 
+  /**
+  validates and generates a txMeta with defaults and puts it in txStateManager
+  store
+
+  @returns {txMeta}
+  */
+
   async addUnapprovedTransaction (txParams) {
     // validate
     const normalizedTxParams = txUtils.normalizeTxParams(txParams)
@@ -145,7 +154,7 @@ module.exports = class TransactionController extends EventEmitter {
     this.emit('newUnapprovedTx', txMeta)
     // add default tx params
     try {
-      txMeta = await this.addTxDefaults(txMeta)
+      txMeta = await this.addTxGasDefaults(txMeta)
     } catch (error) {
       console.log(error)
       this.txStateManager.setTxStatusFailed(txMeta.id, error)
@@ -157,8 +166,12 @@ module.exports = class TransactionController extends EventEmitter {
 
     return txMeta
   }
-
-  async addTxDefaults (txMeta) {
+/**
+  adds the tx gas defaults: gas && gasPrice
+  @param txMeta {object} - the txMeta object
+  @returns {promise} resolves with txMeta
+*/
+  async addTxGasDefaults (txMeta) {
     const txParams = txMeta.txParams
     // ensure value
     txMeta.gasPriceSpecified = Boolean(txParams.gasPrice)
@@ -167,11 +180,18 @@ module.exports = class TransactionController extends EventEmitter {
       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)
   }
 
+  /**
+    creates a new txMeta with the same txParams as the original
+    to allow the user to resign the transaction with a higher gas values
+    @param  originalTxId {number} - the id of the txMeta that
+    you want to attempt to retry
+    @return {txMeta}
+  */
+
   async retryTransaction (originalTxId) {
     const originalTxMeta = this.txStateManager.getTx(originalTxId)
     const lastGasPrice = originalTxMeta.txParams.gasPrice
@@ -185,15 +205,31 @@ module.exports = class TransactionController extends EventEmitter {
     return txMeta
   }
 
+  /**
+  updates the txMeta in the txStateManager
+  @param txMeta {object} - the updated txMeta
+  */
   async updateTransaction (txMeta) {
     this.txStateManager.updateTx(txMeta, 'confTx: user updated transaction')
   }
 
+  /**
+  updates and approves the transaction
+  @param txMeta {object}
+  */
   async updateAndApproveTransaction (txMeta) {
     this.txStateManager.updateTx(txMeta, 'confTx: user approved transaction')
     await this.approveTransaction(txMeta.id)
   }
 
+  /**
+  sets the tx status to approved
+  auto fills the nonce
+  signs the transaction
+  publishes the transaction
+  if any of these steps fails the tx status will be set to failed
+    @param txId {number} - the tx's Id
+  */
   async approveTransaction (txId) {
     let nonceLock
     try {
@@ -225,7 +261,11 @@ module.exports = class TransactionController extends EventEmitter {
       throw err
     }
   }
-
+  /**
+    adds the chain id and signs the transaction and set the status to signed
+    @param txId {number} - the tx's Id
+    @returns - rawTx {string}
+  */
   async signTransaction (txId) {
     const txMeta = this.txStateManager.getTx(txId)
     // add network/chain id
@@ -241,6 +281,11 @@ module.exports = class TransactionController extends EventEmitter {
     return rawTx
   }
 
+  /**
+    publishes the raw tx and sets the txMeta to submitted
+    @param txId {number} - the tx's Id
+    @param rawTx {string} - the hex string of the serialized signed transaction
+  */
   async publishTransaction (txId, rawTx) {
     const txMeta = this.txStateManager.getTx(txId)
     txMeta.rawTx = rawTx
@@ -250,11 +295,19 @@ module.exports = class TransactionController extends EventEmitter {
     this.txStateManager.setTxStatusSubmitted(txId)
   }
 
+  /**
+    convenience method for the ui thats sets the transaction to rejected
+    @param txId {number} - the tx's Id
+  */
   async cancelTransaction (txId) {
     this.txStateManager.setTxStatusRejected(txId)
   }
 
-  // receives a txHash records the tx as signed
+  /**
+    sets the txHas on the txMeta
+    @param txId {number} - the tx's Id
+    @param txHash {string} - the hash for the txMeta
+  */
   setTxHash (txId, txHash) {
     // Add the tx hash to the persisted meta-tx object
     const txMeta = this.txStateManager.getTx(txId)
@@ -265,13 +318,28 @@ module.exports = class TransactionController extends EventEmitter {
 //
 //           PRIVATE METHODS
 //
+  /** maps methods for convenience*/
+  _mapMethods () {
+    /** Returns the state in transaction controller */
+    this.getState = () => this.memStore.getState()
+    /** Returns the network number stored in networkStore */
+    this.getNetwork = () => this.networkStore.getState()
+    /** Returns the user selected address */
+    this.getSelectedAddress = () => this.preferencesStore.getState().selectedAddress
+    /** Returns an array of transactions whos status is unapproved */
+    this.getUnapprovedTxCount = () => Object.keys(this.txStateManager.getUnapprovedTxList()).length
+    /** Returns a number that represents how many transactions have the status submitted*/
+    this.getPendingTxCount = (account) => this.txStateManager.getPendingTransactions(account).length
+    /** see txStateManager */
+    this.getFilteredTxList = (opts) => this.txStateManager.getFilteredTxList(opts)
+  }
 
   _onBootCleanUp () {
     this.txStateManager.getFilteredTxList({
       status: 'unapproved',
       loadingDefaults: true,
     }).forEach((tx) => {
-      this.addTxDefaults(tx)
+      this.addTxGasDefaults(tx)
       .then((txMeta) => {
         txMeta.loadingDefaults = false
         this.txStateManager.updateTx(txMeta, 'transactions: gas estimation for tx on boot')
@@ -339,4 +407,4 @@ module.exports = class TransactionController extends EventEmitter {
     })
     this.memStore.updateState({ unapprovedTxs, selectedAddressTxList })
   }
-}
+}
\ No newline at end of file
-- 
cgit 


From 943eea043cc40ea42ffe757a7115ccbc5585b37b Mon Sep 17 00:00:00 2001
From: frankiebee <frankie.diamond@gmail.com>
Date: Fri, 13 Apr 2018 13:18:45 -0700
Subject: fix up - more docs

---
 app/scripts/controllers/transactions/index.js | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

(limited to 'app/scripts/controllers/transactions/index.js')

diff --git a/app/scripts/controllers/transactions/index.js b/app/scripts/controllers/transactions/index.js
index ca83941fc..c81251cd2 100644
--- a/app/scripts/controllers/transactions/index.js
+++ b/app/scripts/controllers/transactions/index.js
@@ -9,8 +9,6 @@ const PendingTransactionTracker = require('./pending-tx-tracker')
 const NonceTracker = require('./nonce-tracker')
 const txUtils = require('./lib/util')
 
-module.exports = TransactionController
-
 /**
   Transaction Controller is an aggregate of sub-controllers and trackers
   composing them in a way to be exposed to the metamask controller
@@ -356,6 +354,11 @@ add a new unapproved transaction to the pipeline
     })
   }
 
+  /**
+    is called in constructor applies the listeners for pendingTxTracker txStateManager
+    and blockTracker
+    <br>
+  */
   _setupListners () {
     this.txStateManager.on('tx:status-update', this.emit.bind(this, 'tx:status-update'))
     this.pendingTxTracker.on('tx:warning', (txMeta) => {
@@ -407,4 +410,6 @@ add a new unapproved transaction to the pipeline
     })
     this.memStore.updateState({ unapprovedTxs, selectedAddressTxList })
   }
-}
\ No newline at end of file
+}
+
+module.exports = TransactionController
\ No newline at end of file
-- 
cgit 


From eeb9390de81ce6fc92247d5c499e991dce8330bd Mon Sep 17 00:00:00 2001
From: frankiebee <frankie.diamond@gmail.com>
Date: Thu, 19 Apr 2018 11:29:26 -0700
Subject: meta - transactions - docs yo!

---
 app/scripts/controllers/transactions/index.js | 27 ++++++++++++++++-----------
 1 file changed, 16 insertions(+), 11 deletions(-)

(limited to 'app/scripts/controllers/transactions/index.js')

diff --git a/app/scripts/controllers/transactions/index.js b/app/scripts/controllers/transactions/index.js
index c81251cd2..d7287450b 100644
--- a/app/scripts/controllers/transactions/index.js
+++ b/app/scripts/controllers/transactions/index.js
@@ -25,14 +25,15 @@ const txUtils = require('./lib/util')
 
 
 @param {object} opts -
-  - initState, initial transaction list default is an empty array<br>
-  - networkStore, an observable store for network number<br>
-  - blockTracker,<br>
-  - provider,<br>
-  - signTransaction, function the signs an ethereumjs-tx<br>
-  - getGasPrice, optional gas price calculator<br>
-  - txHistoryLimit, number *optional* for limiting how many transactions are in state <br>
-  - preferencesStore,
+  @property  {object} opts.initState initial transaction list default is an empty array
+  @property  {Object} opts.networkStore an observable store for network number
+  @property  {Object} opts.blockTracker
+  @property  {Object} opts.provider
+  @property  {Object} opts.signTransaction function the signs an ethereumjs-tx
+  @property  {function} opts.getGasPrice optional gas price calculator
+  @property  {function} opts.signTransaction ethTx signer that returns a rawTx
+  @property  {number} opts.txHistoryLimit number *optional* for limiting how many transactions are in state
+  @property  {Object} opts.preferencesStore
 @class
 */
 
@@ -50,12 +51,12 @@ class TransactionController extends EventEmitter {
     this.query = new EthQuery(this.provider)
     this.txGasUtil = new TxGasUtil(this.provider)
 
+    this._mapMethods()
     this.txStateManager = new TransactionStateManager({
       initState: opts.initState,
       txHistoryLimit: opts.txHistoryLimit,
       getNetwork: this.getNetwork.bind(this),
     })
-    this._mapMethods()
     this._onBootCleanUp()
 
     this.store = this.txStateManager.store
@@ -92,7 +93,10 @@ class TransactionController extends EventEmitter {
     }
   }
 
-/** Adds a tx to the txlist */
+/**
+  Adds a tx to the txlist
+  @emits ${txMeta.id}:unapproved
+*/
   addTx (txMeta) {
     this.txStateManager.addTx(txMeta)
     this.emit(`${txMeta.id}:unapproved`, txMeta)
@@ -172,6 +176,7 @@ add a new unapproved transaction to the pipeline
   async addTxGasDefaults (txMeta) {
     const txParams = txMeta.txParams
     // ensure value
+    txParams.value = txParams.value ? ethUtil.addHexPrefix(value) : '0x0',
     txMeta.gasPriceSpecified = Boolean(txParams.gasPrice)
     let gasPrice = txParams.gasPrice
     if (!gasPrice) {
@@ -412,4 +417,4 @@ add a new unapproved transaction to the pipeline
   }
 }
 
-module.exports = TransactionController
\ No newline at end of file
+module.exports = TransactionController
-- 
cgit 


From e862a5091e271e8065e9da3c25540612f98a8d2a Mon Sep 17 00:00:00 2001
From: frankiebee <frankie.diamond@gmail.com>
Date: Thu, 19 Apr 2018 11:56:34 -0700
Subject: transactions - fix refernces

---
 app/scripts/controllers/transactions/index.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'app/scripts/controllers/transactions/index.js')

diff --git a/app/scripts/controllers/transactions/index.js b/app/scripts/controllers/transactions/index.js
index 6e47816f8..fc6340bd6 100644
--- a/app/scripts/controllers/transactions/index.js
+++ b/app/scripts/controllers/transactions/index.js
@@ -177,7 +177,7 @@ add a new unapproved transaction to the pipeline
   async addTxGasDefaults (txMeta) {
     const txParams = txMeta.txParams
     // ensure value
-    txParams.value = txParams.value ? ethUtil.addHexPrefix(value) : '0x0',
+    txParams.value = txParams.value ? ethUtil.addHexPrefix(txParams.value) : '0x0'
     txMeta.gasPriceSpecified = Boolean(txParams.gasPrice)
     let gasPrice = txParams.gasPrice
     if (!gasPrice) {
-- 
cgit 


From 621e9334bc7009f7ccd7c1536df00ff6f8240bd3 Mon Sep 17 00:00:00 2001
From: Dan Finlay <dan@danfinlay.com>
Date: Mon, 23 Apr 2018 09:43:18 -0700
Subject: Cleaned up some typos and JSDocs in Transactions

Nonce tracker is not fully documented yet.
Have not yet touched:
- tx-state-manager
- tx-state-history-helper
- util
- tx-gas-utils
- pending-tx-tracker
---
 app/scripts/controllers/transactions/index.js | 33 ++++++++++++++-------------
 1 file changed, 17 insertions(+), 16 deletions(-)

(limited to 'app/scripts/controllers/transactions/index.js')

diff --git a/app/scripts/controllers/transactions/index.js b/app/scripts/controllers/transactions/index.js
index fc6340bd6..321438598 100644
--- a/app/scripts/controllers/transactions/index.js
+++ b/app/scripts/controllers/transactions/index.js
@@ -25,17 +25,18 @@ const log = require('loglevel')
       calculating nonces
 
 
-@param {object} opts -
-  @property  {object} opts.initState initial transaction list default is an empty array
+  @class
+  @param {Object} opts
+  @property  {Object} opts.initState initial transaction list default is an empty array
   @property  {Object} opts.networkStore an observable store for network number
-  @property  {Object} opts.blockTracker
+  @param {Object} opts.blockTracker - An instance of eth-blocktracker
   @property  {Object} opts.provider
+  @param {Object} opts.provider - A network provider.
   @property  {Object} opts.signTransaction function the signs an ethereumjs-tx
   @property  {function} opts.getGasPrice optional gas price calculator
   @property  {function} opts.signTransaction ethTx signer that returns a rawTx
   @property  {number} opts.txHistoryLimit number *optional* for limiting how many transactions are in state
   @property  {Object} opts.preferencesStore
-@class
 */
 
 class TransactionController extends EventEmitter {
@@ -103,21 +104,21 @@ class TransactionController extends EventEmitter {
     this.emit(`${txMeta.id}:unapproved`, txMeta)
   }
 
-/**
+  /**
   wipes the transactions for a given account
-  @param address {string} - hex string of the from address for txs being removed
-*/
+  @param {string} address - hex string of the from address for txs being removed
+  */
   wipeTransactions (address) {
     this.txStateManager.wipeTransactions(address)
   }
 
-/**
-add a new unapproved transaction to the pipeline
-@returns {promise}
-@param txParams {object} - txParams for the transaction
-@param opts {object} - with the key origin to put the origin on the txMeta
+  /**
+  add a new unapproved transaction to the pipeline
 
-*/
+  @returns {promise}
+  @param txParams {Object} - txParams for the transaction
+  @param opts {Object} - with the key origin to put the origin on the txMeta
+  */
   async newUnapprovedTransaction (txParams, opts = {}) {
     log.debug(`MetaMaskController newUnapprovedTransaction ${JSON.stringify(txParams)}`)
     const initialTxMeta = await this.addUnapprovedTransaction(txParams)
@@ -171,7 +172,7 @@ add a new unapproved transaction to the pipeline
   }
 /**
   adds the tx gas defaults: gas && gasPrice
-  @param txMeta {object} - the txMeta object
+  @param txMeta {Object} - the txMeta object
   @returns {promise} resolves with txMeta
 */
   async addTxGasDefaults (txMeta) {
@@ -211,7 +212,7 @@ add a new unapproved transaction to the pipeline
 
   /**
   updates the txMeta in the txStateManager
-  @param txMeta {object} - the updated txMeta
+  @param txMeta {Object} - the updated txMeta
   */
   async updateTransaction (txMeta) {
     this.txStateManager.updateTx(txMeta, 'confTx: user updated transaction')
@@ -219,7 +220,7 @@ add a new unapproved transaction to the pipeline
 
   /**
   updates and approves the transaction
-  @param txMeta {object}
+  @param txMeta {Object}
   */
   async updateAndApproveTransaction (txMeta) {
     this.txStateManager.updateTx(txMeta, 'confTx: user approved transaction')
-- 
cgit 


From 8ffce8b59dc95ffa1af72293f40c21f78fd103bb Mon Sep 17 00:00:00 2001
From: frankiebee <frankie.diamond@gmail.com>
Date: Wed, 25 Apr 2018 11:13:51 -0700
Subject: transactions - more docs and clean ups

---
 app/scripts/controllers/transactions/index.js | 70 +++++++++++++++++----------
 1 file changed, 44 insertions(+), 26 deletions(-)

(limited to 'app/scripts/controllers/transactions/index.js')

diff --git a/app/scripts/controllers/transactions/index.js b/app/scripts/controllers/transactions/index.js
index 321438598..541f1db73 100644
--- a/app/scripts/controllers/transactions/index.js
+++ b/app/scripts/controllers/transactions/index.js
@@ -26,17 +26,16 @@ const log = require('loglevel')
 
 
   @class
-  @param {Object} opts
-  @property  {Object} opts.initState initial transaction list default is an empty array
-  @property  {Object} opts.networkStore an observable store for network number
-  @param {Object} opts.blockTracker - An instance of eth-blocktracker
-  @property  {Object} opts.provider
-  @param {Object} opts.provider - A network provider.
-  @property  {Object} opts.signTransaction function the signs an ethereumjs-tx
-  @property  {function} opts.getGasPrice optional gas price calculator
-  @property  {function} opts.signTransaction ethTx signer that returns a rawTx
-  @property  {number} opts.txHistoryLimit number *optional* for limiting how many transactions are in state
-  @property  {Object} opts.preferencesStore
+  @param {object} - opts
+  @param {object}  opts.initState - initial transaction list default is an empty array
+  @param {Object}  opts.networkStore - an observable store for network number
+  @param {Object}  opts.blockTracker - An instance of eth-blocktracker
+  @param {Object}  opts.provider - A network provider.
+  @param {Function}  opts.signTransaction - function the signs an ethereumjs-tx
+  @param {Function}  [opts.getGasPrice] - optional gas price calculator
+  @param {Function}  opts.signTransaction - ethTx signer that returns a rawTx
+  @param {Number}  [opts.txHistoryLimit] - number *optional* for limiting how many transactions are in state
+  @param {Object}  opts.preferencesStore
 */
 
 class TransactionController extends EventEmitter {
@@ -105,7 +104,7 @@ class TransactionController extends EventEmitter {
   }
 
   /**
-  wipes the transactions for a given account
+  Wipes the transactions for a given account
   @param {string} address - hex string of the from address for txs being removed
   */
   wipeTransactions (address) {
@@ -115,9 +114,9 @@ class TransactionController extends EventEmitter {
   /**
   add a new unapproved transaction to the pipeline
 
-  @returns {promise}
-  @param txParams {Object} - txParams for the transaction
-  @param opts {Object} - with the key origin to put the origin on the txMeta
+  @returns {Promise<string>} the hash of the transaction after being submitted to the network
+  @param txParams {object} - txParams for the transaction
+  @param opts {object} - with the key origin to put the origin on the txMeta
   */
   async newUnapprovedTransaction (txParams, opts = {}) {
     log.debug(`MetaMaskController newUnapprovedTransaction ${JSON.stringify(txParams)}`)
@@ -142,7 +141,7 @@ class TransactionController extends EventEmitter {
   }
 
   /**
-  validates and generates a txMeta with defaults and puts it in txStateManager
+  Validates and generates a txMeta with defaults and puts it in txStateManager
   store
 
   @returns {txMeta}
@@ -173,7 +172,7 @@ class TransactionController extends EventEmitter {
 /**
   adds the tx gas defaults: gas && gasPrice
   @param txMeta {Object} - the txMeta object
-  @returns {promise} resolves with txMeta
+  @returns {Promise<object>} resolves with txMeta
 */
   async addTxGasDefaults (txMeta) {
     const txParams = txMeta.txParams
@@ -190,7 +189,7 @@ class TransactionController extends EventEmitter {
   }
 
   /**
-    creates a new txMeta with the same txParams as the original
+    Creates a new txMeta with the same txParams as the original
     to allow the user to resign the transaction with a higher gas values
     @param  originalTxId {number} - the id of the txMeta that
     you want to attempt to retry
@@ -290,6 +289,7 @@ class TransactionController extends EventEmitter {
     publishes the raw tx and sets the txMeta to submitted
     @param txId {number} - the tx's Id
     @param rawTx {string} - the hex string of the serialized signed transaction
+    @returns {Promise<void>}
   */
   async publishTransaction (txId, rawTx) {
     const txMeta = this.txStateManager.getTx(txId)
@@ -301,15 +301,16 @@ class TransactionController extends EventEmitter {
   }
 
   /**
-    convenience method for the ui thats sets the transaction to rejected
+    Convenience method for the ui thats sets the transaction to rejected
     @param txId {number} - the tx's Id
+    @returns {Promise<void>}
   */
   async cancelTransaction (txId) {
     this.txStateManager.setTxStatusRejected(txId)
   }
 
   /**
-    sets the txHas on the txMeta
+    Sets the txHas on the txMeta
     @param txId {number} - the tx's Id
     @param txHash {string} - the hash for the txMeta
   */
@@ -325,20 +326,29 @@ class TransactionController extends EventEmitter {
 //
   /** maps methods for convenience*/
   _mapMethods () {
-    /** Returns the state in transaction controller */
+    /** @returns the state in transaction controller */
     this.getState = () => this.memStore.getState()
-    /** Returns the network number stored in networkStore */
+    /** @returns the network number stored in networkStore */
     this.getNetwork = () => this.networkStore.getState()
-    /** Returns the user selected address */
+    /** @returns the user selected address */
     this.getSelectedAddress = () => this.preferencesStore.getState().selectedAddress
     /** Returns an array of transactions whos status is unapproved */
     this.getUnapprovedTxCount = () => Object.keys(this.txStateManager.getUnapprovedTxList()).length
-    /** Returns a number that represents how many transactions have the status submitted*/
+    /**
+      @returns a number that represents how many transactions have the status submitted
+      @param account {String} - hex prefixed account
+    */
     this.getPendingTxCount = (account) => this.txStateManager.getPendingTransactions(account).length
     /** see txStateManager */
     this.getFilteredTxList = (opts) => this.txStateManager.getFilteredTxList(opts)
   }
 
+  /**
+    If transaction controller was rebooted with transactions that are uncompleted
+    in steps of the transaction signing or user confirmation process it will either
+    transition txMetas to a failed state or try to redo those tasks.
+  */
+
   _onBootCleanUp () {
     this.txStateManager.getFilteredTxList({
       status: 'unapproved',
@@ -364,13 +374,13 @@ class TransactionController extends EventEmitter {
   /**
     is called in constructor applies the listeners for pendingTxTracker txStateManager
     and blockTracker
-    <br>
   */
   _setupListners () {
     this.txStateManager.on('tx:status-update', this.emit.bind(this, 'tx:status-update'))
     this.pendingTxTracker.on('tx:warning', (txMeta) => {
       this.txStateManager.updateTx(txMeta, 'transactions/pending-tx-tracker#event: tx:warning')
     })
+    this.pendingTxTracker.on('tx:confirmed', (txId) => this.txStateManager.setTxStatusConfirmed(txId))
     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) => {
@@ -393,8 +403,13 @@ class TransactionController extends EventEmitter {
 
   }
 
+  /**
+    Sets other txMeta statuses to dropped if the txMeta that has been confirmed has other transactions
+    in the list have the same nonce
+
+    @param txId {Number} - the txId of the transaction that has been confirmed in a block
+  */
   _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
@@ -409,6 +424,9 @@ class TransactionController extends EventEmitter {
     })
   }
 
+  /**
+    Updates the memStore in transaction controller
+  */
   _updateMemstore () {
     const unapprovedTxs = this.txStateManager.getUnapprovedTxList()
     const selectedAddressTxList = this.txStateManager.getFilteredTxList({
-- 
cgit