v12.0.0 - initial commit

packages/server/lib/cash-in/cash-in-atomic.js

@@ -0,0 +1,106 @@
+const _ = require('lodash/fp')
+const pgp = require('pg-promise')()
+
+const db = require('../db')
+const E = require('../error')
+
+const cashInLow = require('./cash-in-low')
+
+module.exports = { atomic }
+
+function atomic(machineTx) {
+  const TransactionMode = pgp.txMode.TransactionMode
+  const isolationLevel = pgp.txMode.isolationLevel
+  const mode = new TransactionMode({ tiLevel: isolationLevel.serializable })
+  function transaction(t) {
+    const sql = 'select * from cash_in_txs where id=$1'
+    const sql2 = 'select * from bills where cash_in_txs_id=$1'
+
+    return t.oneOrNone(sql, [machineTx.id]).then(row => {
+      if (row && row.tx_version >= machineTx.txVersion)
+        throw new E.StaleTxError({ txId: machineTx.id })
+
+      return t.any(sql2, [machineTx.id]).then(billRows => {
+        const dbTx = cashInLow.toObj(row)
+
+        return preProcess(dbTx, machineTx)
+          .then(preProcessedTx => cashInLow.upsert(t, dbTx, preProcessedTx))
+          .then(r => {
+            return insertNewBills(t, billRows, machineTx).then(newBills =>
+              _.set('newBills', newBills, r),
+            )
+          })
+      })
+    })
+  }
+  return db.tx({ mode }, transaction)
+}
+
+function insertNewBills(t, billRows, machineTx) {
+  const bills = pullNewBills(billRows, machineTx)
+  if (_.isEmpty(bills)) return Promise.resolve([])
+
+  const dbBills = _.map(cashInLow.massage, bills)
+  const billsByDestination = _.countBy(_.get(['destination_unit']), dbBills)
+
+  const columns = [
+    'id',
+    'fiat',
+    'fiat_code',
+    'crypto_code',
+    'cash_in_fee',
+    'cash_in_txs_id',
+    'device_time',
+    'destination_unit',
+  ]
+  const sql = pgp.helpers.insert(dbBills, columns, 'bills')
+  const deviceID = machineTx.deviceId
+  const sql2 = `update devices set recycler1 = recycler1 + $2, recycler2 = recycler2 + $3, recycler3 = recycler3 + $4, recycler4 = recycler4 + $5, recycler5 = recycler5 + $6, recycler6 = recycler6 + $7
+  where device_id = $1`
+
+  return t
+    .none(sql2, [
+      deviceID,
+      _.defaultTo(0, billsByDestination.recycler1),
+      _.defaultTo(0, billsByDestination.recycler2),
+      _.defaultTo(0, billsByDestination.recycler3),
+      _.defaultTo(0, billsByDestination.recycler4),
+      _.defaultTo(0, billsByDestination.recycler5),
+      _.defaultTo(0, billsByDestination.recycler6),
+    ])
+    .then(() => {
+      return t.none(sql)
+    })
+    .then(() => bills)
+}
+
+function pullNewBills(billRows, machineTx) {
+  if (_.isEmpty(machineTx.bills)) return []
+
+  const toBill = _.mapKeys(_.camelCase)
+  const bills = _.map(toBill, billRows)
+
+  return _.differenceBy(_.get('id'), machineTx.bills, bills)
+}
+
+function preProcess(dbTx, machineTx) {
+  // Note: The way this works is if we're clear to send,
+  // we mark the transaction as sendPending.
+  //
+  // If another process is trying to also mark this as sendPending
+  // that means that it saw the tx as sendPending=false.
+  // But if that's true, then it must be serialized before this
+  // (otherwise it would see sendPending=true), and therefore we can't
+  // be seeing sendPending=false (a pre-condition of clearToSend()).
+  // Therefore, one of the conflicting transactions will error,
+  // which is what we want.
+  return new Promise(resolve => {
+    if (!dbTx) return resolve(machineTx)
+
+    if (cashInLow.isClearToSend(dbTx, machineTx)) {
+      return resolve(_.set('sendPending', true, machineTx))
+    }
+
+    return resolve(machineTx)
+  })
+}

packages/server/lib/cash-in/cash-in-low.js

@@ -0,0 +1,195 @@
+const _ = require('lodash/fp')
+const pgp = require('pg-promise')()
+
+const BN = require('../bn')
+const T = require('../time')
+const logger = require('../logger')
+const E = require('../error')
+
+const PENDING_INTERVAL_MS = 60 * T.minutes
+
+const massageFields = [
+  'direction',
+  'cryptoNetwork',
+  'bills',
+  'blacklisted',
+  'blacklistMessage',
+  'addressReuse',
+  'promoCodeApplied',
+  'validWalletScore',
+  'cashInFeeCrypto',
+]
+const massageUpdateFields = _.concat(massageFields, 'cryptoAtoms')
+
+const massage = _.flow(
+  _.omit(massageFields),
+  convertBigNumFields,
+  _.mapKeys(_.snakeCase),
+)
+
+const massageUpdates = _.flow(
+  _.omit(massageUpdateFields),
+  convertBigNumFields,
+  _.mapKeys(_.snakeCase),
+)
+
+module.exports = { toObj, upsert, insert, update, massage, isClearToSend }
+
+function convertBigNumFields(obj) {
+  const convert = value =>
+    value && BN.isBigNumber(value) ? value.toString() : value
+  return _.mapValues(convert, obj)
+}
+
+function toObj(row) {
+  if (!row) return null
+
+  const keys = _.keys(row)
+  let newObj = {}
+
+  keys.forEach(key => {
+    const objKey = _.camelCase(key)
+    if (
+      _.includes(key, [
+        'crypto_atoms',
+        'fiat',
+        'cash_in_fee',
+        'commission_percentage',
+        'raw_ticker_price',
+      ])
+    ) {
+      newObj[objKey] = new BN(row[key])
+      return
+    }
+
+    newObj[objKey] = row[key]
+  })
+
+  newObj.direction = 'cashIn'
+
+  return newObj
+}
+
+function upsert(t, dbTx, preProcessedTx) {
+  if (!dbTx) {
+    return insert(t, preProcessedTx).then(tx => ({ dbTx, tx }))
+  }
+
+  return update(t, dbTx, diff(dbTx, preProcessedTx)).then(tx => ({ dbTx, tx }))
+}
+
+function insert(t, tx) {
+  const dbTx = massage(tx)
+  const sql = pgp.helpers.insert(dbTx, null, 'cash_in_txs') + ' returning *'
+  return t.one(sql).then(toObj)
+}
+
+function update(t, tx, changes) {
+  if (_.isEmpty(changes)) return Promise.resolve(tx)
+
+  const dbChanges = isFinalTxStage(changes)
+    ? massage(changes)
+    : massageUpdates(changes)
+  const sql =
+    pgp.helpers.update(dbChanges, null, 'cash_in_txs') +
+    pgp.as.format(' where id=$1', [tx.id]) +
+    ' returning *'
+
+  return t.one(sql).then(toObj)
+}
+
+function diff(oldTx, newTx) {
+  let updatedTx = {}
+
+  if (!oldTx) throw new Error('oldTx must not be null')
+  if (!newTx) throw new Error('newTx must not be null')
+
+  _.forEach(fieldKey => {
+    const oldField = oldTx[fieldKey]
+    const newField = newTx[fieldKey]
+    if (fieldKey === 'bills') return
+    if (_.isEqualWith(nilEqual, oldField, newField)) return
+
+    if (!ensureRatchet(oldField, newField, fieldKey)) {
+      logger.warn(
+        'Value from lamassu-machine would violate ratchet [%s]',
+        fieldKey,
+      )
+      logger.warn('Old tx: %j', oldTx)
+      logger.warn('New tx: %j', newTx)
+      throw new E.RatchetError(
+        'Value from lamassu-machine would violate ratchet',
+      )
+    }
+
+    updatedTx[fieldKey] = newField
+  }, _.keys(newTx))
+
+  return updatedTx
+}
+
+function ensureRatchet(oldField, newField, fieldKey) {
+  const monotonic = [
+    'cryptoAtoms',
+    'fiat',
+    'send',
+    'sendConfirmed',
+    'operatorCompleted',
+    'timedout',
+    'txVersion',
+    'batched',
+    'discount',
+  ]
+  const free = [
+    'sendPending',
+    'error',
+    'errorCode',
+    'customerId',
+    'discountSource',
+  ]
+
+  if (_.isNil(oldField)) return true
+  if (_.includes(fieldKey, monotonic))
+    return isMonotonic(oldField, newField, fieldKey)
+
+  if (_.includes(fieldKey, free)) {
+    if (_.isNil(newField)) return false
+    return true
+  }
+
+  if (_.isNil(newField)) return false
+  if (BN.isBigNumber(oldField) && BN.isBigNumber(newField))
+    return new BN(oldField).eq(newField)
+  if (oldField.toString() === newField.toString()) return true
+
+  return false
+}
+
+function isMonotonic(oldField, newField, fieldKey) {
+  if (_.isNil(newField)) return false
+  if (_.isBoolean(oldField)) return oldField === newField || !oldField
+  if (BN.isBigNumber(oldField)) return oldField.lte(newField)
+  if (_.isNumber(oldField)) return oldField <= newField
+
+  throw new Error(`Unexpected value [${fieldKey}]: ${oldField}, ${newField}`)
+}
+
+function nilEqual(a, b) {
+  if (_.isNil(a) && _.isNil(b)) return true
+
+  return undefined
+}
+
+function isClearToSend(oldTx, newTx) {
+  const now = Date.now()
+
+  return (
+    (newTx.send || newTx.batched) &&
+    (!oldTx || (!oldTx.sendPending && !oldTx.sendConfirmed)) &&
+    newTx.created > now - PENDING_INTERVAL_MS
+  )
+}
+
+function isFinalTxStage(txChanges) {
+  return txChanges.send || txChanges.batched
+}

packages/server/lib/cash-in/cash-in-tx.js

@@ -0,0 +1,272 @@
+const _ = require('lodash/fp')
+const pgp = require('pg-promise')()
+const pEachSeries = require('p-each-series')
+
+const blacklist = require('../blacklist')
+const db = require('../db')
+const plugins = require('../plugins')
+const logger = require('../logger')
+const settingsLoader = require('../new-settings-loader')
+const configManager = require('../new-config-manager')
+const notifier = require('../notifier')
+const constants = require('../constants')
+
+const cashInAtomic = require('./cash-in-atomic')
+const cashInLow = require('./cash-in-low')
+
+const PENDING_INTERVAL = '60 minutes'
+const MAX_PENDING = 10
+
+const TRANSACTION_STATES = `
+case
+  when operator_completed and error = 'Operator cancel' then 'Cancelled'
+  when error is not null then 'Error'
+  when send_confirmed then 'Sent'
+  when ((not send_confirmed) and (created <= now() - interval '${PENDING_INTERVAL}')) then 'Expired'
+  else 'Pending'
+end`
+
+module.exports = {
+  post,
+  monitorPending,
+  cancel,
+  doesTxReuseAddress,
+  PENDING_INTERVAL,
+  TRANSACTION_STATES,
+}
+
+function post(machineTx, pi) {
+  logger.silly('Updating cashin tx:', machineTx)
+  return cashInAtomic.atomic(machineTx).then(r => {
+    const updatedTx = r.tx
+    let addressReuse = false
+
+    const promises = [settingsLoader.loadConfig()]
+
+    const isFirstPost = !r.tx.fiat || r.tx.fiat.isZero()
+    if (isFirstPost) {
+      promises.push(
+        checkForBlacklisted(updatedTx),
+        doesTxReuseAddress(updatedTx),
+        getWalletScore(updatedTx, pi),
+      )
+    }
+
+    return Promise.all(promises).then(
+      ([
+        config,
+        blacklisted = false,
+        isReusedAddress = false,
+        walletScore = null,
+      ]) => {
+        const { rejectAddressReuse } = configManager.getCompliance(config)
+        const isBlacklisted = !!blacklisted
+
+        if (isBlacklisted) {
+          notifier.notifyIfActive('compliance', 'blacklistNotify', r.tx, false)
+        } else if (isReusedAddress && rejectAddressReuse) {
+          notifier.notifyIfActive('compliance', 'blacklistNotify', r.tx, true)
+          addressReuse = true
+        }
+        return postProcess(r, pi, isBlacklisted, addressReuse, walletScore)
+          .then(changes =>
+            _.set(
+              'walletScore',
+              _.isNil(walletScore) ? null : walletScore.score,
+              changes,
+            ),
+          )
+          .then(changes => cashInLow.update(db, updatedTx, changes))
+          .then(
+            _.flow(
+              _.set('bills', machineTx.bills),
+              _.set('blacklisted', isBlacklisted),
+              _.set('blacklistMessage', blacklisted?.content),
+              _.set('addressReuse', addressReuse),
+              _.set(
+                'validWalletScore',
+                _.isNil(walletScore) || walletScore.isValid,
+              ),
+            ),
+          )
+      },
+    )
+  })
+}
+
+function registerTrades(pi, r) {
+  _.forEach(bill => pi.buy(bill, r.tx), r.newBills)
+}
+
+function logAction(rec, tx) {
+  const action = {
+    tx_id: tx.id,
+    action: rec.action || (rec.sendConfirmed ? 'sendCoins' : 'sendCoinsError'),
+    error: rec.error,
+    error_code: rec.errorCode,
+    tx_hash: rec.txHash,
+  }
+
+  const sql = pgp.helpers.insert(action, null, 'cash_in_actions')
+
+  return db.none(sql).then(_.constant(rec))
+}
+
+function logActionById(action, _rec, txId) {
+  const rec = _.assign(_rec, { action, tx_id: txId })
+  const sql = pgp.helpers.insert(rec, null, 'cash_in_actions')
+
+  return db.none(sql)
+}
+
+function checkForBlacklisted(tx) {
+  return blacklist.blocked(tx.toAddress)
+}
+
+function postProcess(r, pi, isBlacklisted, addressReuse, walletScore) {
+  if (addressReuse) {
+    return Promise.resolve({
+      operatorCompleted: true,
+      error: 'Address Reused',
+    })
+  }
+
+  if (isBlacklisted) {
+    return Promise.resolve({
+      operatorCompleted: true,
+      error: 'Blacklisted Address',
+    })
+  }
+
+  if (!_.isNil(walletScore) && !walletScore.isValid) {
+    return Promise.resolve({
+      walletScore: walletScore.score,
+      operatorCompleted: true,
+      error: 'Chain analysis score is above defined threshold',
+      errorCode: 'scoreThresholdReached',
+    })
+  }
+
+  registerTrades(pi, r)
+
+  if (!cashInLow.isClearToSend(r.dbTx, r.tx)) return Promise.resolve({})
+
+  return pi
+    .sendCoins(r.tx)
+    .then(txObj => {
+      if (txObj.batched) {
+        return {
+          batched: true,
+          batchTime: 'now()^',
+          sendPending: true,
+          error: null,
+          errorCode: null,
+        }
+      }
+
+      return {
+        txHash: txObj.txid,
+        fee: txObj.fee,
+        sendConfirmed: true,
+        sendTime: 'now()^',
+        sendPending: false,
+        error: null,
+        errorCode: null,
+      }
+    })
+    .catch(err => {
+      // Important: We don't know what kind of error this is
+      // so not safe to assume that funds weren't sent.
+
+      // Setting sendPending to true ensures that the transaction gets
+      // silently terminated and no retries are done
+
+      return {
+        sendTime: 'now()^',
+        error: err.message,
+        errorCode: err.name,
+        sendPending: true,
+      }
+    })
+    .then(sendRec => {
+      pi.notifyOperator(r.tx, sendRec).catch(err =>
+        logger.error('Failure sending transaction notification', err),
+      )
+      return logAction(sendRec, r.tx)
+    })
+}
+
+// This feels like it can be simplified,
+// but it's the most concise query to express the requirement and its edge cases.
+// At most only one authenticated customer can use an address.
+// If the current customer is anon, we can still allow one other customer to use the address,
+// So we count distinct customers plus the current customer if they are not anonymous.
+// To prevent malicious blocking of address, we only check for txs with actual fiat
+function doesTxReuseAddress({ toAddress, customerId }) {
+  const sql = `
+    SELECT COUNT(*) > 1 as exists
+    FROM (SELECT DISTINCT customer_id
+          FROM cash_in_txs
+          WHERE to_address = $1
+            AND customer_id != $3
+            AND fiat > 0
+          UNION
+          SELECT $2
+          WHERE $2 != $3) t;
+  `
+  return db
+    .one(sql, [toAddress, customerId, constants.anonymousCustomer.uuid])
+    .then(({ exists }) => exists)
+}
+
+function getWalletScore(tx, pi) {
+  return pi.isWalletScoringEnabled(tx).then(isEnabled => {
+    if (!isEnabled) return null
+    return pi.rateAddress(tx.cryptoCode, tx.toAddress)
+  })
+}
+
+function monitorPending(settings) {
+  const sql = `select * from cash_in_txs
+  where created > now() - interval $1
+  and send
+  and not send_confirmed
+  and not send_pending
+  and not operator_completed
+  order by created
+  limit $2`
+
+  const processPending = row => {
+    const tx = cashInLow.toObj(row)
+    const pi = plugins(settings, tx.deviceId)
+
+    return post(tx, pi).catch(logger.error)
+  }
+
+  return db
+    .any(sql, [PENDING_INTERVAL, MAX_PENDING])
+    .then(rows => pEachSeries(rows, row => processPending(row)))
+    .catch(logger.error)
+}
+
+function cancel(txId) {
+  const updateRec = {
+    error: 'Operator cancel',
+    error_code: 'operatorCancel',
+    operator_completed: true,
+    batch_id: null,
+  }
+
+  return Promise.resolve()
+    .then(() => {
+      return (
+        pgp.helpers.update(updateRec, null, 'cash_in_txs') +
+        pgp.as.format(' where id=$1', [txId])
+      )
+    })
+    .then(sql => db.result(sql, false))
+    .then(res => {
+      if (res.rowCount !== 1) throw new Error('No such tx-id')
+    })
+    .then(() => logActionById('operatorCompleted', {}, txId))
+}