refactor cash-in and cash-out

lib/cash-out/cash-out-atomic.js

@@ -0,0 +1,160 @@
+const _ = require('lodash/fp')
+const pgp = require('pg-promise')()
+
+const E = require('../error')
+const socket = require('../socket-client')
+
+const helper = require('./cash-out-helper')
+const cashOutActions = require('./cash-out-actions')
+const cashOutLow = require('./cash-out-low')
+
+const toObj = helper.toObj
+
+module.exports = {atomic}
+
+function atomic (tx, pi, fromClient) {
+  const TransactionMode = pgp.txMode.TransactionMode
+  const isolationLevel = pgp.txMode.isolationLevel
+  const tmSRD = new TransactionMode({tiLevel: isolationLevel.serializable})
+
+  function transaction (t) {
+    const sql = 'select * from cash_out_txs where id=$1'
+
+    return t.oneOrNone(sql, [tx.id])
+    .then(toObj)
+    .then(oldTx => {
+      const isStale = fromClient && oldTx && (oldTx.txVersion >= tx.txVersion)
+      if (isStale) throw new E.StaleTxError('Stale tx')
+
+      return preProcess(t, oldTx, tx, pi)
+      .then(preProcessedTx => cashOutLow.upsert(t, oldTx, preProcessedTx))
+    })
+  }
+
+  transaction.txMode = tmSRD
+
+  return transaction
+}
+
+function preProcess (t, oldTx, newTx, pi) {
+  if (!oldTx) {
+    return pi.isHd(newTx)
+    .then(isHd => nextHd(t, isHd, newTx))
+    .then(newTxHd => {
+      return pi.newAddress(newTxHd)
+      .then(_.set('toAddress', _, newTxHd))
+    })
+    .then(addressedTx => {
+      const rec = {to_address: addressedTx.toAddress}
+      return cashOutActions.logAction(t, 'provisionAddress', rec, addressedTx)
+    })
+    .catch(err => {
+      return cashOutActions.logError(t, 'provisionAddress', err, newTx)
+      .then(() => { throw err })
+    })
+  }
+
+  return Promise.resolve(updateStatus(oldTx, newTx))
+  .then(updatedTx => {
+    if (updatedTx.status !== oldTx.status) {
+      const isZeroConf = pi.isZeroConf(updatedTx)
+      if (wasJustAuthorized(oldTx, updatedTx, isZeroConf)) pi.sell(updatedTx)
+
+      const rec = {
+        to_address: updatedTx.toAddress,
+        tx_hash: updatedTx.txHash
+      }
+
+      return cashOutActions.logAction(t, updatedTx.status, rec, updatedTx)
+    }
+
+    if (!oldTx.dispenseConfirmed && updatedTx.dispenseConfirmed) {
+      return cashOutActions.logDispense(t, updatedTx)
+      .then(updateCassettes(t, updatedTx))
+    }
+
+    if (!oldTx.phone && newTx.phone) {
+      return cashOutActions.logAction(t, 'addPhone', {}, updatedTx)
+    }
+
+    if (!oldTx.redeem && newTx.redeem) {
+      return cashOutActions.logAction(t, 'redeemLater', {}, updatedTx)
+    }
+
+    return updatedTx
+  })
+}
+
+function nextHd (t, isHd, tx) {
+  if (!isHd) return Promise.resolve(tx)
+
+  return t.one("select nextval('hd_indices_seq') as hd_index")
+  .then(row => _.set('hdIndex', row.hd_index, tx))
+}
+
+function updateCassettes (t, tx) {
+  const sql = `update devices set
+  cassette1 = cassette1 - $1,
+  cassette2 = cassette2 - $2
+  where device_id = $3
+  returning cassette1, cassette2`
+
+  const values = [
+    tx.bills[0].dispensed + tx.bills[0].rejected,
+    tx.bills[1].dispensed + tx.bills[1].rejected,
+    tx.deviceId
+  ]
+
+  return t.one(sql, values)
+  .then(r => socket.emit(_.assign(r, {op: 'cassetteUpdate', deviceId: tx.deviceId})))
+}
+
+function wasJustAuthorized (oldTx, newTx, isZeroConf) {
+  const isAuthorized = () => _.includes(oldTx.status, ['notSeen', 'published']) &&
+    _.includes(newTx.status, ['authorized', 'instant', 'confirmed'])
+
+  const isConfirmed = () => _.includes(oldTx.status, ['notSeen', 'published', 'authorized']) &&
+    _.includes(newTx.status, ['instant', 'confirmed'])
+
+  return isZeroConf ? isAuthorized() : isConfirmed()
+}
+
+function isPublished (status) {
+  return _.includes(status, ['published', 'rejected', 'authorized', 'instant', 'confirmed'])
+}
+
+function isConfirmed (status) {
+  return status === 'confirmed'
+}
+
+function updateStatus (oldTx, newTx) {
+  const oldStatus = oldTx.status
+  const newStatus = ratchetStatus(oldStatus, newTx.status)
+
+  const publishedAt = !oldTx.publishedAt && isPublished(newStatus)
+  ? 'now()^'
+  : undefined
+
+  const confirmedAt = !oldTx.confirmedAt && isConfirmed(newStatus)
+  ? 'now()^'
+  : undefined
+
+  const updateRec = {
+    publishedAt,
+    confirmedAt,
+    status: newStatus
+  }
+
+  return _.merge(newTx, updateRec)
+}
+
+function ratchetStatus (oldStatus, newStatus) {
+  const statusOrder = ['notSeen', 'published', 'rejected',
+    'authorized', 'instant', 'confirmed']
+
+  if (oldStatus === newStatus) return oldStatus
+  if (newStatus === 'insufficientFunds') return newStatus
+
+  const idx = Math.max(statusOrder.indexOf(oldStatus), statusOrder.indexOf(newStatus))
+  return statusOrder[idx]
+}