@mojaloop/central-ledger 9.2.2 → 15.1.3-snapshot.2

package/src/models/participant/participantLimit.js

@@ -34,27 +34,27 @@ const Logger = require('@mojaloop/central-services-logger')
 
 const insert = async (participantLimit) => {
   try {
-    return await Db.participantLimit.insert(participantLimit)
+    return await Db.from('participantLimit').insert(participantLimit)
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }
 
 const update = async (participantLimit) => {
   try {
-    return await Db.participantLimit.update({ participantCurrencyId: participantLimit.participantCurrencyId }, { value: participantLimit.value, isActive: participantLimit.isActive })
+    return await Db.from('participantLimit').update({ participantCurrencyId: participantLimit.participantCurrencyId }, { value: participantLimit.value, isActive: participantLimit.isActive })
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }
 
-const getLimitByCurrencyId = async (participantCurrencyId) => {
+const getAll = async () => {
   try {
-    return await Db.participantLimit.findOne({ participantCurrencyId })
+    return await Db.from('participantLimit').find({})
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }
@@ -73,9 +73,9 @@ const getLimitByCurrencyId = async (participantCurrencyId) => {
 
 const getByParticipantCurrencyId = async (participantCurrencyId) => {
   try {
-    return Db.participantLimit.findOne({ participantCurrencyId, isActive: 1 })
+    return Db.from('participantLimit').findOne({ participantCurrencyId, isActive: 1 })
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }
@@ -94,9 +94,9 @@ const getByParticipantCurrencyId = async (participantCurrencyId) => {
 
 const destroyByParticipantCurrencyId = async (participantCurrencyId) => {
   try {
-    return Db.participantLimit.destroy({ participantCurrencyId })
+    return Db.from('participantLimit').destroy({ participantCurrencyId })
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }
@@ -121,7 +121,7 @@ const destroyByParticipantId = async (participantId) => {
       .whereIn('participantCurrencyId', participantCurrencyIdList)
       .del()
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }
@@ -129,8 +129,8 @@ const destroyByParticipantId = async (participantId) => {
 module.exports = {
   insert,
   update,
-  getLimitByCurrencyId,
   getByParticipantCurrencyId,
+  getAll,
   destroyByParticipantCurrencyId,
   destroyByParticipantId
 }

package/src/models/participant/participantLimitCached.js

@@ -0,0 +1,124 @@
+/*****
+ License
+ --------------
+ Copyright © 2017 Bill & Melinda Gates Foundation
+ The Mojaloop files are made available by the Bill & Melinda Gates Foundation under the Apache License, Version 2.0 (the "License") and you may not use these files except in compliance with the License. You may obtain a copy of the License at
+ http://www.apache.org/licenses/LICENSE-2.0
+ Unless required by applicable law or agreed to in writing, the Mojaloop files are distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ Contributors
+ --------------
+ This is the official list of the Mojaloop project contributors for this file.
+ Names of the original copyright holders (individuals or organizations)
+ should be listed with a '*' in the first column. People who have
+ contributed from an organization can be listed under the organization
+ that actually holds the copyright for their contributions (see the
+ Gates Foundation organization for an example). Those individuals should have
+ their names indented and be marked with a '-'. Email address can be added
+ optionally within square brackets <email>.
+ * Gates Foundation
+ - Name Surname <name.surname@gatesfoundation.com>
+
+ * Roman Pietrzak <roman.pietrzak@modusbox.com>
+ --------------
+ ******/
+
+'use strict'
+
+const ErrorHandler = require('@mojaloop/central-services-error-handling')
+const Cache = require('../../lib/cache')
+const ParticipantLimitModel = require('../../models/participant/participantLimit')
+const Metrics = require('@mojaloop/central-services-metrics')
+
+let cacheClient
+let participantLimitAllCacheKey
+
+/*
+  Private API
+*/
+const buildUnifiedParticipantsLimitData = (allLimitParticipants) => {
+  // build indexes (or indices?) - optimization for byId and byName access
+  const indexByParticipantCurrencyId = {}
+
+  allLimitParticipants.forEach((oneLimitParticipant) => {
+    // LimitParticipant API returns Date type, but cache internals will serialize it to String
+    // by calling JSON.stringify(), which calls .toISOString() on a Date object.
+    // Let's ensure all places return same kind of String.
+    oneLimitParticipant.createdDate = JSON.stringify(oneLimitParticipant.createdDate)
+
+    // Add to indexes
+    indexByParticipantCurrencyId[oneLimitParticipant.participantCurrencyId] = oneLimitParticipant
+  })
+
+  // build unified structure - indexes + data
+  const unifiedLimitParticipants = {
+    indexByParticipantCurrencyId,
+    allLimitParticipants
+  }
+
+  return unifiedLimitParticipants
+}
+
+const getParticipantLimitCached = async () => {
+  const histTimer = Metrics.getHistogram(
+    'model_participant',
+    'model_getParticipantLimitCached - Metrics for participant model',
+    ['success', 'queryName', 'hit']
+  ).startTimer()
+  // Do we have valid participantsLimit list in the cache ?
+  let cachedLimitParticipants = cacheClient.get(participantLimitAllCacheKey)
+  if (!cachedLimitParticipants) {
+    // No participantsLimit in the cache, so fetch from participantsLimit API
+    const allLimitParticipants = await ParticipantLimitModel.getAll()
+    cachedLimitParticipants = buildUnifiedParticipantsLimitData(allLimitParticipants)
+
+    // store in cache
+    cacheClient.set(participantLimitAllCacheKey, cachedLimitParticipants)
+    histTimer({ success: true, queryName: 'model_getParticipantLimitCached', hit: false })
+  } else {
+    // unwrap participants list from catbox structure
+    cachedLimitParticipants = cachedLimitParticipants.item
+    histTimer({ success: true, queryName: 'model_getParticipantLimitCached', hit: true })
+  }
+  return cachedLimitParticipants
+}
+
+/*
+  Public API
+*/
+exports.initialize = async () => {
+  /* Register as cache client */
+  const participantLimitCacheClientMeta = {
+    id: 'participantLimit',
+    preloadCache: getParticipantLimitCached
+  }
+
+  cacheClient = Cache.registerCacheClient(participantLimitCacheClientMeta)
+  participantLimitAllCacheKey = cacheClient.createKey('all')
+}
+
+exports.invalidateParticipantLimitCache = async () => {
+  cacheClient.drop(participantLimitAllCacheKey)
+}
+
+exports.getByParticipantCurrencyId = async (id) => {
+  const cachedLimitParticipants = await getParticipantLimitCached()
+  const participantLimitById = cachedLimitParticipants.indexByParticipantCurrencyId[id]
+  return participantLimitById
+}
+
+const withInvalidate = (theFunctionName) => {
+  return async (...args) => {
+    try {
+      const result = await ParticipantLimitModel[theFunctionName](...args)
+      await exports.invalidateParticipantLimitCache()
+      return result
+    } catch (err) {
+      throw ErrorHandler.Factory.reformatFSPIOPError(err)
+    }
+  }
+}
+
+exports.insert = withInvalidate('insert')
+exports.update = withInvalidate('update')
+exports.destroyByParticipantCurrencyId = withInvalidate('destroyByParticipantCurrencyId')
+exports.destroyByParticipantId = withInvalidate('destroyByParticipantId')

package/src/models/participant/participantPosition.js

@@ -35,6 +35,7 @@
 const Db = require('../../lib/db')
 const ParticipantCurrencyModel = require('./participantCurrencyCached')
 const Logger = require('@mojaloop/central-services-logger')
+const ErrorHandler = require('@mojaloop/central-services-error-handling')
 
 /**
  * @function GetByParticipantCurrencyId
@@ -50,9 +51,9 @@ const Logger = require('@mojaloop/central-services-logger')
 
 const getByParticipantCurrencyId = async (participantCurrencyId) => {
   try {
-    return Db.participantPosition.findOne({ participantCurrencyId })
+    return Db.from('participantPosition').findOne({ participantCurrencyId })
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }
@@ -71,9 +72,9 @@ const getByParticipantCurrencyId = async (participantCurrencyId) => {
 
 const destroyByParticipantCurrencyId = async (participantCurrencyId) => {
   try {
-    return Db.participantPosition.destroy({ participantCurrencyId })
+    return Db.from('participantPosition').destroy({ participantCurrencyId })
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }
@@ -98,12 +99,40 @@ const destroyByParticipantId = async (participantId) => {
       .whereIn('participantCurrencyId', participantCurrencyIdList)
       .del()
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }
 
+const createParticipantPositionRecords = async (participantPositions, trx) => {
+  try {
+    const knex = Db.getKnex()
+    const trxFunction = async (trx, doCommit = true) => {
+      try {
+        await knex
+          .batchInsert('participantPosition', participantPositions)
+          .transacting(trx)
+        if (doCommit) {
+          await trx.commit
+        }
+      } catch (err) {
+        if (doCommit) {
+          await trx.rollback
+        }
+        throw ErrorHandler.Factory.reformatFSPIOPError(err)
+      }
+    }
+    if (trx) {
+      return trxFunction(trx, false)
+    } else {
+      return knex.transaction(trxFunction)
+    }
+  } catch (err) {
+    throw ErrorHandler.Factory.reformatFSPIOPError(err)
+  }
+}
 module.exports = {
+  createParticipantPositionRecords,
   getByParticipantCurrencyId,
   destroyByParticipantCurrencyId,
   destroyByParticipantId

package/src/models/participant/participantPositionChange.js

@@ -30,6 +30,7 @@
 
 const Db = require('../../lib/db')
 const Logger = require('@mojaloop/central-services-logger')
+const Metrics = require('@mojaloop/central-services-metrics')
 
 /**
  * @function getByParticipantPositionId
@@ -44,17 +45,24 @@ const Logger = require('@mojaloop/central-services-logger')
  */
 
 const getByParticipantPositionId = async (participantPositionId) => {
+  const histTimer = Metrics.getHistogram(
+    'model_participant',
+    'model_getByParticipantPositionId - Metrics for participant model',
+    ['success', 'queryName', 'hit']
+  ).startTimer()
   try {
-    return await Db.participantPositionChange.query(async (builder) => {
+    return await Db.from('participantPositionChange').query(async (builder) => {
       const result = builder
         .where({ 'participantPositionChange.participantPositionId': participantPositionId })
         .select('participantPositionChange.*')
         .orderBy('participantPositionChangeId', 'desc')
         .first()
+      histTimer({ success: true, queryName: 'model_getByParticipantPositionId', hit: false })
       return result
     })
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
+    histTimer({ success: false, queryName: 'model_getByParticipantPositionId', hit: false })
     throw err
   }
 }

package/src/models/position/facade.js

@@ -33,18 +33,36 @@
 const Db = require('../../lib/db')
 const Enum = require('@mojaloop/central-services-shared').Enum
 const participantFacade = require('../participant/facade')
+const SettlementModelCached = require('../../models/settlement/settlementModelCached')
 const Logger = require('@mojaloop/central-services-logger')
 const Time = require('@mojaloop/central-services-shared').Util.Time
 const MLNumber = require('@mojaloop/ml-number')
 const ErrorHandler = require('@mojaloop/central-services-error-handling')
 const Config = require('../../lib/config')
 
+const Metrics = require('@mojaloop/central-services-metrics')
+
 const prepareChangeParticipantPositionTransaction = async (transferList) => {
+  const histTimerChangeParticipantPositionEnd = Metrics.getHistogram(
+    'model_position',
+    'facade_prepareChangeParticipantPositionTransaction - Metrics for position model',
+    ['success', 'queryName']
+  ).startTimer()
   try {
     const knex = await Db.getKnex()
     const participantName = transferList[0].value.content.payload.payerFsp
     const currencyId = transferList[0].value.content.payload.amount.currency
+    const allSettlementModels = await SettlementModelCached.getAll()
+    let settlementModels = allSettlementModels.filter(model => model.currencyId === currencyId)
+    if (settlementModels.length === 0) {
+      settlementModels = allSettlementModels.filter(model => model.currencyId === null) // Default settlement model
+      if (settlementModels.length === 0) {
+        throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.GENERIC_SETTLEMENT_ERROR, 'Unable to find a matching or default, Settlement Model')
+      }
+    }
+    const settlementModel = settlementModels.find(sm => sm.ledgerAccountTypeId === Enum.Accounts.LedgerAccountType.POSITION)
     const participantCurrency = await participantFacade.getByNameAndCurrency(participantName, currencyId, Enum.Accounts.LedgerAccountType.POSITION)
+    const settlementParticipantCurrency = await participantFacade.getByNameAndCurrency(participantName, currencyId, settlementModel.settlementAccountTypeId)
     const processedTransfers = {} // The list of processed transfers - so that we can store the additional information around the decision. Most importantly the "running" position
     const reservedTransfers = []
     const abortedTransfers = []
@@ -52,6 +70,11 @@ const prepareChangeParticipantPositionTransaction = async (transferList) => {
     const transferIdList = []
     const limitAlarms = []
     let sumTransfersInBatch = 0
+    const histTimerChangeParticipantPositionTransEnd = Metrics.getHistogram(
+      'model_position',
+      'facade_prepareChangeParticipantPositionTransaction_transaction - Metrics for position model',
+      ['success', 'queryName']
+    ).startTimer()
     await knex.transaction(async (trx) => {
       try {
         const transactionTimestamp = Time.getUTCString(new Date())
@@ -73,9 +96,21 @@ const prepareChangeParticipantPositionTransaction = async (transferList) => {
 
           const id = transfer.value.content.payload.transferId
           transferIdList.push(id)
+          // DUPLICATE of TransferStateChangeModel getByTransferId
           initialTransferStateChangePromises.push(await knex('transferStateChange').transacting(trx).where('transferId', id).orderBy('transferStateChangeId', 'desc').first())
         }
+        const histTimerinitialTransferStateChangeListEnd = Metrics.getHistogram(
+          'model_position',
+          'facade_prepareChangeParticipantPositionTransaction_transaction_initialTransferStateChangeList - Metrics for position model',
+          ['success', 'queryName']
+        ).startTimer()
         const initialTransferStateChangeList = await Promise.all(initialTransferStateChangePromises)
+        histTimerinitialTransferStateChangeListEnd({ success: true, queryName: 'facade_prepareChangeParticipantPositionTransaction_transaction_initialTransferStateChangeList' })
+        const histTimerTransferStateChangePrepareAndBatchInsertEnd = Metrics.getHistogram(
+          'model_position',
+          'facade_prepareChangeParticipantPositionTransaction_transaction_transferStateChangeBatchInsert - Metrics for position model',
+          ['success', 'queryName']
+        ).startTimer()
         for (const id in initialTransferStateChangeList) {
           const transferState = initialTransferStateChangeList[id]
           const transfer = transferList[id].value.content.payload
@@ -95,19 +130,48 @@ const prepareChangeParticipantPositionTransaction = async (transferList) => {
         }
         const abortedTransferStateChangeList = Object.keys(abortedTransfers).length && Array.from(transferIdList.map(transferId => abortedTransfers[transferId].transferState))
         Object.keys(abortedTransferStateChangeList).length && await knex.batchInsert('transferStateChange', abortedTransferStateChangeList).transacting(trx)
+        histTimerTransferStateChangePrepareAndBatchInsertEnd({ success: true, queryName: 'facade_prepareChangeParticipantPositionTransaction_transaction_transferStateChangeBatchInsert' })
         // Get the effective position for this participantCurrency at the start of processing the Batch
         // and reserved the total value of the transfers in the batch (sumTransfersInBatch)
-        const initialParticipantPosition = await knex('participantPosition').transacting(trx).where({ participantCurrencyId: participantCurrency.participantCurrencyId }).forUpdate().select('*').first()
+        const histTimerUpdateEffectivePositionEnd = Metrics.getHistogram(
+          'model_position',
+          'facade_prepareChangeParticipantPositionTransaction_transaction_UpdateEffectivePosition - Metrics for position model',
+          ['success', 'queryName']
+        ).startTimer()
+        const participantPositions = await knex('participantPosition')
+          .transacting(trx)
+          .whereIn('participantCurrencyId', [participantCurrency.participantCurrencyId, settlementParticipantCurrency.participantCurrencyId])
+          .forUpdate()
+          .select('*')
+        const initialParticipantPosition = participantPositions.find(position => position.participantCurrencyId === participantCurrency.participantCurrencyId)
+        const settlementParticipantPosition = participantPositions.find(position => position.participantCurrencyId === settlementParticipantCurrency.participantCurrencyId)
         const currentPosition = new MLNumber(initialParticipantPosition.value)
         const reservedPosition = new MLNumber(initialParticipantPosition.reservedValue)
         const effectivePosition = currentPosition.add(reservedPosition).toFixed(Config.AMOUNT.SCALE)
         initialParticipantPosition.reservedValue = new MLNumber(initialParticipantPosition.reservedValue).add(sumTransfersInBatch).toFixed(Config.AMOUNT.SCALE)
         initialParticipantPosition.changedDate = transactionTimestamp
         await knex('participantPosition').transacting(trx).where({ participantPositionId: initialParticipantPosition.participantPositionId }).update(initialParticipantPosition)
+        histTimerUpdateEffectivePositionEnd({ success: true, queryName: 'facade_prepareChangeParticipantPositionTransaction_transaction_UpdateEffectivePosition' })
         // Get the actual position limit and calculate the available position for the transfers to use in this batch
         // Note: see optimisation decision notes to understand the justification for the algorithm
+        const histTimerValidatePositionBatchEnd = Metrics.getHistogram(
+          'model_position',
+          'facade_prepareChangeParticipantPositionTransaction_transaction_ValidatePositionBatch - Metrics for position model',
+          ['success', 'queryName']
+        ).startTimer()
         const participantLimit = await participantFacade.getParticipantLimitByParticipantCurrencyLimit(participantCurrency.participantId, participantCurrency.currencyId, Enum.Accounts.LedgerAccountType.POSITION, Enum.Accounts.ParticipantLimitType.NET_DEBIT_CAP)
-        let availablePosition = new MLNumber(participantLimit.value).subtract(effectivePosition).toFixed(Config.AMOUNT.SCALE)
+        // Calculate liquidity cover as per story OTC-651
+        let liquidityCover
+        let payerLimit
+        if (settlementModel.settlementDelayId === Enum.Settlements.SettlementDelay.IMMEDIATE) {
+          liquidityCover = new MLNumber(settlementParticipantPosition.value).add(new MLNumber(participantLimit.value))
+          payerLimit = new MLNumber(participantLimit.value)
+        } else {
+          liquidityCover = new MLNumber(settlementParticipantPosition.value).multiply(-1)
+          payerLimit = new MLNumber(participantLimit.value)
+        }
+        let availablePositionBasedOnLiquidityCover = liquidityCover.subtract(effectivePosition).toFixed(Config.AMOUNT.SCALE)
+        let availablePositionBasedOnPayerLimit = payerLimit.subtract(effectivePosition).toFixed(Config.AMOUNT.SCALE)
         /* Validate entire batch if availablePosition >= sumTransfersInBatch - the impact is that applying per transfer rules would require to be handled differently
            since further rules are expected we do not do this at this point
            As we enter this next step the order in which the transfer is processed against the Position is critical.
@@ -117,19 +181,32 @@ const prepareChangeParticipantPositionTransaction = async (transferList) => {
         let sumReserved = 0 // Record the sum of the transfers we allow to progress to RESERVED
         for (const transferId in reservedTransfers) {
           const { transfer, transferState, rawMessage, transferAmount } = reservedTransfers[transferId]
-          if (new MLNumber(availablePosition).toNumber() >= transferAmount.toNumber()) {
-            availablePosition = new MLNumber(availablePosition).subtract(transferAmount).toFixed(Config.AMOUNT.SCALE)
-            transferState.transferStateId = Enum.Transfers.TransferState.RESERVED
-            sumReserved = new MLNumber(sumReserved).add(transferAmount).toFixed(Config.AMOUNT.SCALE) /* actually used */
-          } else {
+          if (new MLNumber(availablePositionBasedOnLiquidityCover).toNumber() < transferAmount.toNumber()) {
             transferState.transferStateId = Enum.Transfers.TransferInternalState.ABORTED_REJECTED
             transferState.reason = ErrorHandler.Enums.FSPIOPErrorCodes.PAYER_FSP_INSUFFICIENT_LIQUIDITY.message
-            rawMessage.value.content.payload = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.PAYER_FSP_INSUFFICIENT_LIQUIDITY, null, null, null, rawMessage.value.content.payload.extensionList).toApiErrorObject(Config.ERROR_HANDLING)
+            reservedTransfers[transferId].fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.PAYER_FSP_INSUFFICIENT_LIQUIDITY, null, null, null, rawMessage.value.content.payload.extensionList)
+            rawMessage.value.content.payload = reservedTransfers[transferId].fspiopError.toApiErrorObject(Config.ERROR_HANDLING)
+          } else if (new MLNumber(availablePositionBasedOnPayerLimit).toNumber() < transferAmount.toNumber()) {
+            transferState.transferStateId = Enum.Transfers.TransferInternalState.ABORTED_REJECTED
+            transferState.reason = ErrorHandler.Enums.FSPIOPErrorCodes.PAYER_LIMIT_ERROR.message
+            reservedTransfers[transferId].fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.PAYER_LIMIT_ERROR, null, null, null, rawMessage.value.content.payload.extensionList)
+            rawMessage.value.content.payload = reservedTransfers[transferId].fspiopError.toApiErrorObject(Config.ERROR_HANDLING)
+          } else {
+            availablePositionBasedOnLiquidityCover = new MLNumber(availablePositionBasedOnLiquidityCover).subtract(transferAmount).toFixed(Config.AMOUNT.SCALE)
+            availablePositionBasedOnPayerLimit = new MLNumber(availablePositionBasedOnPayerLimit).subtract(transferAmount).toFixed(Config.AMOUNT.SCALE)
+            transferState.transferStateId = Enum.Transfers.TransferState.RESERVED
+            sumReserved = new MLNumber(sumReserved).add(transferAmount).toFixed(Config.AMOUNT.SCALE) /* actually used */
           }
           const runningPosition = new MLNumber(currentPosition).add(sumReserved).toFixed(Config.AMOUNT.SCALE) /* effective position */
           const runningReservedValue = new MLNumber(sumTransfersInBatch).subtract(sumReserved).toFixed(Config.AMOUNT.SCALE)
           processedTransfers[transferId] = { transferState, transfer, rawMessage, transferAmount, runningPosition, runningReservedValue }
         }
+        histTimerValidatePositionBatchEnd({ success: true, queryName: 'facade_prepareChangeParticipantPositionTransaction_transaction_ValidatePositionBatch' })
+        const histTimerUpdateParticipantPositionEnd = Metrics.getHistogram(
+          'model_position',
+          'facade_prepareChangeParticipantPositionTransaction_transaction_UpdateParticipantPosition - Metrics for position model',
+          ['success', 'queryName']
+        ).startTimer()
         /*
           Update the participantPosition with the eventual impact of the Batch
           So the position moves forward by the sum of the transfers actually reserved (sumReserved)
@@ -142,13 +219,19 @@ const prepareChangeParticipantPositionTransaction = async (transferList) => {
           changedDate: transactionTimestamp
         })
         // TODO this limit needs to be clarified
-        if (processedPositionValue.toNumber() > new MLNumber(participantLimit.value).multiply(participantLimit.thresholdAlarmPercentage).toNumber()) {
+        if (processedPositionValue.toNumber() > liquidityCover.multiply(participantLimit.thresholdAlarmPercentage).toNumber()) {
           limitAlarms.push(participantLimit)
         }
+        histTimerUpdateParticipantPositionEnd({ success: true, queryName: 'facade_prepareChangeParticipantPositionTransaction_transaction_UpdateParticipantPosition' })
         /*
           Persist the transferStateChanges and associated participantPositionChange entry to record the running position
           The transferStateChanges need to be persisted first (by INSERTing) to have the PK reference
         */
+        const histTimerPersistTransferStateChangeEnd = Metrics.getHistogram(
+          'model_position',
+          'facade_prepareChangeParticipantPositionTransaction_transaction_PersistTransferState - Metrics for position model',
+          ['success', 'queryName']
+        ).startTimer()
         await knex('transfer').transacting(trx).forUpdate().whereIn('transferId', transferIdList).select('*')
         const processedTransferStateChangeList = Object.keys(processedTransfers).length && Array.from(transferIdList.map(transferId => processedTransfers[transferId].transferState))
         const processedTransferStateChangeIdList = processedTransferStateChangeList && Object.keys(processedTransferStateChangeList).length && await knex.batchInsert('transferStateChange', processedTransferStateChangeList).transacting(trx)
@@ -166,10 +249,13 @@ const prepareChangeParticipantPositionTransaction = async (transferList) => {
           batchParticipantPositionChange.push(participantPositionChange)
         }
         batchParticipantPositionChange.length && await knex.batchInsert('participantPositionChange', batchParticipantPositionChange).transacting(trx)
-        await trx.commit
+        histTimerPersistTransferStateChangeEnd({ success: true, queryName: 'facade_prepareChangeParticipantPositionTransaction_transaction_PersistTransferState' })
+        await trx.commit()
+        histTimerChangeParticipantPositionTransEnd({ success: true, queryName: 'facade_prepareChangeParticipantPositionTransaction_transaction' })
       } catch (err) {
-        Logger.error(err)
-        await trx.rollback
+        Logger.isErrorEnabled && Logger.error(err)
+        await trx.rollback()
+        histTimerChangeParticipantPositionTransEnd({ success: false, queryName: 'facade_prepareChangeParticipantPositionTransaction_transaction' })
         throw ErrorHandler.Factory.reformatFSPIOPError(err)
       }
     })
@@ -178,14 +264,21 @@ const prepareChangeParticipantPositionTransaction = async (transferList) => {
         ? reservedTransfers[transferId]
         : abortedTransfers[transferId]
     ))
+    histTimerChangeParticipantPositionEnd({ success: true, queryName: 'facade_prepareChangeParticipantPositionTransaction' })
     return { preparedMessagesList, limitAlarms }
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
+    histTimerChangeParticipantPositionEnd({ success: false, queryName: 'facade_prepareChangeParticipantPositionTransaction' })
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
 
 const changeParticipantPositionTransaction = async (participantCurrencyId, isReversal, amount, transferStateChange) => {
+  const histTimerChangeParticipantPositionTransactionEnd = Metrics.getHistogram(
+    'model_position',
+    'facade_changeParticipantPositionTransaction - Metrics for position model',
+    ['success', 'queryName']
+  ).startTimer()
   try {
     const knex = await Db.getKnex()
     await knex.transaction(async (trx) => {
@@ -214,16 +307,17 @@ const changeParticipantPositionTransaction = async (participantCurrencyId, isRev
           createdDate: transactionTimestamp
         }
         await knex('participantPositionChange').transacting(trx).insert(participantPositionChange)
-        await trx.commit
+        await trx.commit()
+        histTimerChangeParticipantPositionTransactionEnd({ success: true, queryName: 'facade_changeParticipantPositionTransaction' })
       } catch (err) {
-        await trx.rollback
+        await trx.rollback()
         throw ErrorHandler.Factory.reformatFSPIOPError(err)
       }
     }).catch((err) => {
       throw ErrorHandler.Factory.reformatFSPIOPError(err)
     })
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -244,7 +338,7 @@ const changeParticipantPositionTransaction = async (participantCurrencyId, isRev
 
 const getByNameAndCurrency = async (name, ledgerAccountTypeId, currencyId = null) => {
   try {
-    return Db.participantPosition.query(builder => {
+    return Db.from('participantPosition').query(builder => {
       return builder.innerJoin('participantCurrency AS pc', 'participantPosition.participantCurrencyId', 'pc.participantCurrencyId')
         .innerJoin('participant AS p', 'pc.participantId', 'p.participantId')
         .where({
@@ -268,7 +362,7 @@ const getByNameAndCurrency = async (name, ledgerAccountTypeId, currencyId = null
 
 const getAllByNameAndCurrency = async (name, currencyId = null) => {
   try {
-    return Db.participantPosition.query(builder => {
+    return Db.from('participantPosition').query(builder => {
       return builder.innerJoin('participantCurrency AS pc', 'participantPosition.participantCurrencyId', 'pc.participantCurrencyId')
         .innerJoin('ledgerAccountType AS lap', 'lap.ledgerAccountTypeId', 'pc.ledgerAccountTypeId')
         .innerJoin('participant AS p', 'pc.participantId', 'p.participantId')

package/src/models/position/participantPosition.js

@@ -29,27 +29,27 @@ const Logger = require('@mojaloop/central-services-logger')
 
 const insert = async (participantPosition) => {
   try {
-    return await Db.participantPosition.insert(participantPosition)
+    return await Db.from('participantPosition').insert(participantPosition)
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }
 
 const update = async (participantPosition) => {
   try {
-    return await Db.participantPosition.update({ participantCurrencyId: participantPosition.participantCurrencyId }, { value: participantPosition.value, reservedValue: participantPosition.reservedValue, changedDate: new Date() })
+    return await Db.from('participantPosition').update({ participantCurrencyId: participantPosition.participantCurrencyId }, { value: participantPosition.value, reservedValue: participantPosition.reservedValue, changedDate: new Date() })
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }
 
 const getPositionByCurrencyId = async (participantCurrencyId) => {
   try {
-    return await Db.participantPosition.findOne({ participantCurrencyId })
+    return await Db.from('participantPosition').findOne({ participantCurrencyId })
   } catch (err) {
-    Logger.error(err)
+    Logger.isErrorEnabled && Logger.error(err)
     throw err
   }
 }