@mojaloop/central-ledger 17.7.8 → 17.8.0-orb.1

package/src/models/participant/facade.js

@@ -28,17 +28,20 @@
  * @module src/models/participant/facade/
  */
 
-const Db = require('../../lib/db')
 const Time = require('@mojaloop/central-services-shared').Util.Time
+const { Enum } = require('@mojaloop/central-services-shared')
 const ErrorHandler = require('@mojaloop/central-services-error-handling')
 const Metrics = require('@mojaloop/central-services-metrics')
+
+const Db = require('../../lib/db')
 const Cache = require('../../lib/cache')
 const ParticipantModelCached = require('../../models/participant/participantCached')
 const ParticipantCurrencyModelCached = require('../../models/participant/participantCurrencyCached')
 const ParticipantLimitCached = require('../../models/participant/participantLimitCached')
+const externalParticipantModelCached = require('../../models/participant/externalParticipantCached')
 const Config = require('../../lib/config')
 const SettlementModelModel = require('../settlement/settlementModel')
-const { Enum } = require('@mojaloop/central-services-shared')
+const { logger } = require('../../shared/logger')
 
 const getByNameAndCurrency = async (name, currencyId, ledgerAccountTypeId, isCurrencyActive) => {
   const histTimerParticipantGetByNameAndCurrencyEnd = Metrics.getHistogram(
@@ -106,6 +109,72 @@ const getByNameAndCurrency = async (name, currencyId, ledgerAccountTypeId, isCur
   }
 }
 
+const getByIDAndCurrency = async (participantId, currencyId, ledgerAccountTypeId, isCurrencyActive) => {
+  const histTimerParticipantGetByIDAndCurrencyEnd = Metrics.getHistogram(
+    'model_participant',
+    'facade_getByIDAndCurrency - Metrics for participant model',
+    ['success', 'queryName']
+  ).startTimer()
+
+  try {
+    let participant
+    if (Cache.isCacheEnabled()) {
+      /* Cached version - fetch data from Models (which we trust are cached) */
+      /* find paricipant by ID */
+      participant = await ParticipantModelCached.getById(participantId)
+      if (participant) {
+        /* use the paricipant id and incoming params to prepare the filter */
+        const searchFilter = {
+          participantId,
+          currencyId,
+          ledgerAccountTypeId
+        }
+        if (isCurrencyActive !== undefined) {
+          searchFilter.isActive = isCurrencyActive
+        }
+
+        /* find the participantCurrency by prepared filter */
+        const participantCurrency = await ParticipantCurrencyModelCached.findOneByParams(searchFilter)
+
+        if (participantCurrency) {
+          /* mix requested data from participantCurrency */
+          participant.participantCurrencyId = participantCurrency.participantCurrencyId
+          participant.currencyId = participantCurrency.currencyId
+          participant.currencyIsActive = participantCurrency.isActive
+        }
+      }
+    } else {
+      /* Non-cached version - direct call to DB */
+      participant = await Db.from('participant').query(async (builder) => {
+        let b = builder
+          .where({ 'participant.participantId': participantId })
+          .andWhere({ 'pc.currencyId': currencyId })
+          .andWhere({ 'pc.ledgerAccountTypeId': ledgerAccountTypeId })
+          .innerJoin('participantCurrency AS pc', 'pc.participantId', 'participant.participantId')
+          .select(
+            'participant.*',
+            'pc.participantCurrencyId',
+            'pc.currencyId',
+            'pc.isActive AS currencyIsActive'
+          )
+          .first()
+
+        if (isCurrencyActive !== undefined) {
+          b = b.andWhere({ 'pc.isActive': isCurrencyActive })
+        }
+        return b
+      })
+    }
+
+    histTimerParticipantGetByIDAndCurrencyEnd({ success: true, queryName: 'facade_getByIDAndCurrency' })
+
+    return participant
+  } catch (err) {
+    histTimerParticipantGetByIDAndCurrencyEnd({ success: false, queryName: 'facade_getByIDAndCurrency' })
+    throw ErrorHandler.Factory.reformatFSPIOPError(err)
+  }
+}
+
 const getParticipantLimitByParticipantIdAndCurrencyId = async (participantId, currencyId, ledgerAccountTypeId) => {
   try {
     return await Db.from('participant').query(async (builder) => {
@@ -259,34 +328,30 @@ const addEndpoint = async (participantId, endpoint) => {
   try {
     const knex = Db.getKnex()
     return knex.transaction(async trx => {
-      try {
-        const endpointType = await knex('endpointType').where({ name: endpoint.type, isActive: 1 }).select('endpointTypeId').first()
-        // let endpointType = await trx.first('endpointTypeId').from('endpointType').where({ 'name': endpoint.type, 'isActive': 1 })
+      const endpointType = await knex('endpointType').where({
+        name: endpoint.type,
+        isActive: 1
+      }).select('endpointTypeId').first()
 
-        const existingEndpoint = await knex('participantEndpoint').transacting(trx).forUpdate().select('*')
-          .where({
-            participantId,
-            endpointTypeId: endpointType.endpointTypeId,
-            isActive: 1
-          })
-        if (Array.isArray(existingEndpoint) && existingEndpoint.length > 0) {
-          await knex('participantEndpoint').transacting(trx).update({ isActive: 0 }).where('participantEndpointId', existingEndpoint[0].participantEndpointId)
-        }
-        const newEndpoint = {
+      const existingEndpoint = await knex('participantEndpoint').transacting(trx).forUpdate().select('*')
+        .where({
           participantId,
           endpointTypeId: endpointType.endpointTypeId,
-          value: endpoint.value,
-          isActive: 1,
-          createdBy: 'unknown'
-        }
-        const result = await knex('participantEndpoint').transacting(trx).insert(newEndpoint)
-        newEndpoint.participantEndpointId = result[0]
-        await trx.commit
-        return newEndpoint
-      } catch (err) {
-        await trx.rollback
-        throw err
+          isActive: 1
+        })
+      if (Array.isArray(existingEndpoint) && existingEndpoint.length > 0) {
+        await knex('participantEndpoint').transacting(trx).update({ isActive: 0 }).where('participantEndpointId', existingEndpoint[0].participantEndpointId)
       }
+      const newEndpoint = {
+        participantId,
+        endpointTypeId: endpointType.endpointTypeId,
+        value: endpoint.value,
+        isActive: 1,
+        createdBy: 'unknown'
+      }
+      const result = await knex('participantEndpoint').transacting(trx).insert(newEndpoint)
+      newEndpoint.participantEndpointId = result[0]
+      return newEndpoint
     })
   } catch (err) {
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
@@ -413,73 +478,67 @@ const addLimitAndInitialPosition = async (participantCurrencyId, settlementAccou
   try {
     const knex = Db.getKnex()
     return knex.transaction(async trx => {
-      try {
-        const limitType = await knex('participantLimitType').where({ name: limitPositionObj.limit.type, isActive: 1 }).select('participantLimitTypeId').first()
-        const participantLimit = {
-          participantCurrencyId,
-          participantLimitTypeId: limitType.participantLimitTypeId,
-          value: limitPositionObj.limit.value,
-          isActive: 1,
-          createdBy: 'unknown'
-        }
-        const result = await knex('participantLimit').transacting(trx).insert(participantLimit)
-        participantLimit.participantLimitId = result[0]
-
-        const allSettlementModels = await SettlementModelModel.getAll()
-        const settlementModels = allSettlementModels.filter(model => model.currencyId === limitPositionObj.currency)
-        if (Array.isArray(settlementModels) && settlementModels.length > 0) {
-          for (const settlementModel of settlementModels) {
-            const positionAccount = await getByNameAndCurrency(limitPositionObj.name, limitPositionObj.currency, settlementModel.ledgerAccountTypeId)
-            const settlementAccount = await getByNameAndCurrency(limitPositionObj.name, limitPositionObj.currency, settlementModel.settlementAccountTypeId)
-
-            const participantPosition = {
-              participantCurrencyId: positionAccount.participantCurrencyId,
-              value: (settlementModel.ledgerAccountTypeId === Enum.Accounts.LedgerAccountType.POSITION ? limitPositionObj.initialPosition : 0),
-              reservedValue: 0
-            }
-            await knex('participantPosition').transacting(trx).insert(participantPosition)
+      const limitType = await knex('participantLimitType').where({ name: limitPositionObj.limit.type, isActive: 1 }).select('participantLimitTypeId').first()
+      const participantLimit = {
+        participantCurrencyId,
+        participantLimitTypeId: limitType.participantLimitTypeId,
+        value: limitPositionObj.limit.value,
+        isActive: 1,
+        createdBy: 'unknown'
+      }
+      const result = await knex('participantLimit').transacting(trx).insert(participantLimit)
+      participantLimit.participantLimitId = result[0]
+
+      const allSettlementModels = await SettlementModelModel.getAll()
+      const settlementModels = allSettlementModels.filter(model => model.currencyId === limitPositionObj.currency)
+      if (Array.isArray(settlementModels) && settlementModels.length > 0) {
+        for (const settlementModel of settlementModels) {
+          const positionAccount = await getByNameAndCurrency(limitPositionObj.name, limitPositionObj.currency, settlementModel.ledgerAccountTypeId)
+          const settlementAccount = await getByNameAndCurrency(limitPositionObj.name, limitPositionObj.currency, settlementModel.settlementAccountTypeId)
 
-            const settlementPosition = {
-              participantCurrencyId: settlementAccount.participantCurrencyId,
-              value: 0,
-              reservedValue: 0
-            }
-            await knex('participantPosition').transacting(trx).insert(settlementPosition)
-            if (setCurrencyActive) { // if the flag is true then set the isActive flag for corresponding participantCurrency record to true
-              await knex('participantCurrency').transacting(trx).update({ isActive: 1 }).where('participantCurrencyId', positionAccount.participantCurrencyId)
-              await knex('participantCurrency').transacting(trx).update({ isActive: 1 }).where('participantCurrencyId', settlementAccount.participantCurrencyId)
-              await ParticipantCurrencyModelCached.invalidateParticipantCurrencyCache()
-              await ParticipantLimitCached.invalidateParticipantLimitCache()
-            }
-          }
-        } else {
           const participantPosition = {
-            participantCurrencyId,
-            value: limitPositionObj.initialPosition,
+            participantCurrencyId: positionAccount.participantCurrencyId,
+            value: (settlementModel.ledgerAccountTypeId === Enum.Accounts.LedgerAccountType.POSITION ? limitPositionObj.initialPosition : 0),
             reservedValue: 0
           }
-          const participantPositionResult = await knex('participantPosition').transacting(trx).insert(participantPosition)
-          participantPosition.participantPositionId = participantPositionResult[0]
+          await knex('participantPosition').transacting(trx).insert(participantPosition)
+
           const settlementPosition = {
-            participantCurrencyId: settlementAccountId,
+            participantCurrencyId: settlementAccount.participantCurrencyId,
             value: 0,
             reservedValue: 0
           }
           await knex('participantPosition').transacting(trx).insert(settlementPosition)
           if (setCurrencyActive) { // if the flag is true then set the isActive flag for corresponding participantCurrency record to true
-            await knex('participantCurrency').transacting(trx).update({ isActive: 1 }).where('participantCurrencyId', participantCurrencyId)
-            await knex('participantCurrency').transacting(trx).update({ isActive: 1 }).where('participantCurrencyId', settlementAccountId)
+            await knex('participantCurrency').transacting(trx).update({ isActive: 1 }).where('participantCurrencyId', positionAccount.participantCurrencyId)
+            await knex('participantCurrency').transacting(trx).update({ isActive: 1 }).where('participantCurrencyId', settlementAccount.participantCurrencyId)
             await ParticipantCurrencyModelCached.invalidateParticipantCurrencyCache()
             await ParticipantLimitCached.invalidateParticipantLimitCache()
           }
         }
-
-        await trx.commit
-        return true
-      } catch (err) {
-        await trx.rollback
-        throw err
+      } else {
+        const participantPosition = {
+          participantCurrencyId,
+          value: limitPositionObj.initialPosition,
+          reservedValue: 0
+        }
+        const participantPositionResult = await knex('participantPosition').transacting(trx).insert(participantPosition)
+        participantPosition.participantPositionId = participantPositionResult[0]
+        const settlementPosition = {
+          participantCurrencyId: settlementAccountId,
+          value: 0,
+          reservedValue: 0
+        }
+        await knex('participantPosition').transacting(trx).insert(settlementPosition)
+        if (setCurrencyActive) { // if the flag is true then set the isActive flag for corresponding participantCurrency record to true
+          await knex('participantCurrency').transacting(trx).update({ isActive: 1 }).where('participantCurrencyId', participantCurrencyId)
+          await knex('participantCurrency').transacting(trx).update({ isActive: 1 }).where('participantCurrencyId', settlementAccountId)
+          await ParticipantCurrencyModelCached.invalidateParticipantCurrencyCache()
+          await ParticipantLimitCached.invalidateParticipantLimitCache()
+        }
       }
+
+      return true
     })
   } catch (err) {
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
@@ -510,7 +569,7 @@ const addLimitAndInitialPosition = async (participantCurrencyId, settlementAccou
 
 const adjustLimits = async (participantCurrencyId, limit, trx) => {
   try {
-    const trxFunction = async (trx, doCommit = true) => {
+    const trxFunction = async (trx) => {
       try {
         const limitType = await knex('participantLimitType').where({ name: limit.type, isActive: 1 }).select('participantLimitTypeId').first()
         // const limitType = await trx.first('participantLimitTypeId').from('participantLimitType').where({ 'name': limit.type, 'isActive': 1 })
@@ -535,23 +594,17 @@ const adjustLimits = async (participantCurrencyId, limit, trx) => {
         }
         const result = await knex('participantLimit').transacting(trx).insert(newLimit)
         newLimit.participantLimitId = result[0]
-        if (doCommit) {
-          await trx.commit
-        }
         return {
           participantLimit: newLimit
         }
       } catch (err) {
-        if (doCommit) {
-          await trx.rollback
-        }
         throw ErrorHandler.Factory.reformatFSPIOPError(err)
       }
     }
 
     const knex = Db.getKnex()
     if (trx) {
-      return trxFunction(trx, false)
+      return trxFunction(trx)
     } else {
       return knex.transaction(trxFunction)
     }
@@ -640,34 +693,28 @@ const addHubAccountAndInitPosition = async (participantId, currencyId, ledgerAcc
   try {
     const knex = Db.getKnex()
     return knex.transaction(async trx => {
-      try {
-        let result
-        const participantCurrency = {
-          participantId,
-          currencyId,
-          ledgerAccountTypeId,
-          createdBy: 'unknown',
-          isActive: 1,
-          createdDate: Time.getUTCString(new Date())
-        }
-        result = await knex('participantCurrency').transacting(trx).insert(participantCurrency)
-        await ParticipantCurrencyModelCached.invalidateParticipantCurrencyCache()
-        participantCurrency.participantCurrencyId = result[0]
-        const participantPosition = {
-          participantCurrencyId: participantCurrency.participantCurrencyId,
-          value: 0,
-          reservedValue: 0
-        }
-        result = await knex('participantPosition').transacting(trx).insert(participantPosition)
-        participantPosition.participantPositionId = result[0]
-        await trx.commit
-        return {
-          participantCurrency,
-          participantPosition
-        }
-      } catch (err) {
-        await trx.rollback
-        throw err
+      let result
+      const participantCurrency = {
+        participantId,
+        currencyId,
+        ledgerAccountTypeId,
+        createdBy: 'unknown',
+        isActive: 1,
+        createdDate: Time.getUTCString(new Date())
+      }
+      result = await knex('participantCurrency').transacting(trx).insert(participantCurrency)
+      await ParticipantCurrencyModelCached.invalidateParticipantCurrencyCache()
+      participantCurrency.participantCurrencyId = result[0]
+      const participantPosition = {
+        participantCurrencyId: participantCurrency.participantCurrencyId,
+        value: 0,
+        reservedValue: 0
+      }
+      result = await knex('participantPosition').transacting(trx).insert(participantPosition)
+      participantPosition.participantPositionId = result[0]
+      return {
+        participantCurrency,
+        participantPosition
       }
     })
   } catch (err) {
@@ -706,7 +753,7 @@ const getAllNonHubParticipantsWithCurrencies = async (trx) => {
   try {
     const HUB_ACCOUNT_NAME = Config.HUB_NAME
     const knex = Db.getKnex()
-    const trxFunction = async (trx, doCommit = true) => {
+    const trxFunction = async (trx) => {
       try {
         const res = await knex.distinct('participant.participantId', 'pc.participantId', 'pc.currencyId')
           .from('participant')
@@ -714,19 +761,13 @@ const getAllNonHubParticipantsWithCurrencies = async (trx) => {
           .whereNot('participant.name', HUB_ACCOUNT_NAME)
           .transacting(trx)
 
-        if (doCommit) {
-          await trx.commit
-        }
         return res
       } catch (err) {
-        if (doCommit) {
-          await trx.rollback
-        }
         throw ErrorHandler.Factory.reformatFSPIOPError(err)
       }
     }
     if (trx) {
-      return trxFunction(trx, false)
+      return trxFunction(trx)
     } else {
       return knex.transaction(trxFunction)
     }
@@ -735,9 +776,36 @@ const getAllNonHubParticipantsWithCurrencies = async (trx) => {
   }
 }
 
+const getExternalParticipantIdByNameOrCreate = async ({ name, proxyId }) => {
+  try {
+    let externalFsp = await externalParticipantModelCached.getByName(name)
+    if (!externalFsp) {
+      const proxy = await ParticipantModelCached.getByName(proxyId)
+      if (!proxy) {
+        throw new Error(`Proxy participant not found: ${proxyId}`)
+      }
+      const externalParticipantId = await externalParticipantModelCached.create({
+        name,
+        proxyId: proxy.participantId
+      })
+      externalFsp = externalParticipantId
+        ? { externalParticipantId }
+        : await externalParticipantModelCached.getByName(name)
+    }
+    const id = externalFsp?.externalParticipantId
+    logger.verbose('getExternalParticipantIdByNameOrCreate result:', { id, name })
+    return id
+  } catch (err) {
+    logger.child({ name, proxyId }).warn('error in getExternalParticipantIdByNameOrCreate:', err)
+    return null
+    // todo: think, if we need to rethrow an error here?
+  }
+}
+
 module.exports = {
   addHubAccountAndInitPosition,
   getByNameAndCurrency,
+  getByIDAndCurrency,
   getParticipantLimitByParticipantIdAndCurrencyId,
   getEndpoint,
   getAllEndpoints,
@@ -750,5 +818,6 @@ module.exports = {
   getParticipantLimitsByParticipantId,
   getAllAccountsByNameAndCurrency,
   getLimitsForAllParticipants,
-  getAllNonHubParticipantsWithCurrencies
+  getAllNonHubParticipantsWithCurrencies,
+  getExternalParticipantIdByNameOrCreate
 }

package/src/models/participant/participant.js

@@ -43,7 +43,8 @@ exports.create = async (participant) => {
   try {
     const result = await Db.from('participant').insert({
       name: participant.name,
-      createdBy: 'unknown'
+      createdBy: 'unknown',
+      isProxy: !!participant.isProxy
     })
     return result
   } catch (err) {

package/src/models/participant/participantCurrency.js

@@ -43,7 +43,7 @@ exports.create = async (participantId, currencyId, ledgerAccountTypeId, isActive
 
 exports.getAll = async () => {
   try {
-    return Db.from('participantCurrency').find({}, { order: 'participantCurrencyId asc' })
+    return await Db.from('participantCurrency').find({}, { order: 'participantCurrencyId asc' })
   } catch (err) {
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }

package/src/models/participant/participantPosition.js

@@ -107,23 +107,17 @@ const destroyByParticipantId = async (participantId) => {
 const createParticipantPositionRecords = async (participantPositions, trx) => {
   try {
     const knex = Db.getKnex()
-    const trxFunction = async (trx, doCommit = true) => {
+    const trxFunction = async (trx) => {
       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)
+      return trxFunction(trx)
     } else {
       return knex.transaction(trxFunction)
     }

package/src/models/position/batch.js

@@ -63,6 +63,28 @@ const getLatestTransferStateChangesByTransferIdList = async (trx, transfersIdLis
   }
 }
 
+const getLatestFxTransferStateChangesByCommitRequestIdList = async (trx, commitRequestIdList) => {
+  const knex = await Db.getKnex()
+  try {
+    const latestFxTransferStateChanges = {}
+    const results = await knex('fxTransferStateChange')
+      .transacting(trx)
+      .whereIn('fxTransferStateChange.commitRequestId', commitRequestIdList)
+      .orderBy('fxTransferStateChangeId', 'desc')
+      .select('*')
+
+    for (const result of results) {
+      if (!latestFxTransferStateChanges[result.commitRequestId]) {
+        latestFxTransferStateChanges[result.commitRequestId] = result
+      }
+    }
+    return latestFxTransferStateChanges
+  } catch (err) {
+    Logger.isErrorEnabled && Logger.error(err)
+    throw err
+  }
+}
+
 const getAllParticipantCurrency = async (trx) => {
   const knex = await Db.getKnex()
   if (trx) {
@@ -138,6 +160,11 @@ const bulkInsertTransferStateChanges = async (trx, transferStateChangeList) => {
   return await knex.batchInsert('transferStateChange', transferStateChangeList).transacting(trx)
 }
 
+const bulkInsertFxTransferStateChanges = async (trx, fxTransferStateChangeList) => {
+  const knex = await Db.getKnex()
+  return await knex.batchInsert('fxTransferStateChange', fxTransferStateChangeList).transacting(trx)
+}
+
 const bulkInsertParticipantPositionChanges = async (trx, participantPositionChangeList) => {
   const knex = await Db.getKnex()
   return await knex.batchInsert('participantPositionChange', participantPositionChangeList).transacting(trx)
@@ -184,14 +211,76 @@ const getTransferByIdsForReserve = async (trx, transferIds) => {
   return {}
 }
 
+const getFxTransferInfoList = async (trx, commitRequestId, transferParticipantRoleTypeId, ledgerEntryTypeId) => {
+  try {
+    const knex = await Db.getKnex()
+    const transferInfos = await knex('fxTransferParticipant')
+      .transacting(trx)
+      .where({
+        'fxTransferParticipant.transferParticipantRoleTypeId': transferParticipantRoleTypeId,
+        'fxTransferParticipant.ledgerEntryTypeId': ledgerEntryTypeId
+      })
+      .whereIn('fxTransferParticipant.commitRequestId', commitRequestId)
+      .select(
+        'fxTransferParticipant.*'
+      )
+    const info = {}
+    // This should key the transfer info with the latest transferStateChangeId
+    for (const transferInfo of transferInfos) {
+      if (!(transferInfo.commitRequestId in info)) {
+        info[transferInfo.commitRequestId] = transferInfo
+      }
+    }
+    return info
+  } catch (err) {
+    Logger.isErrorEnabled && Logger.error(err)
+    throw err
+  }
+}
+
+// This model assumes that there is only one RESERVED participantPositionChange per commitRequestId and participantPositionId.
+// If an fxTransfer use case changes in the future where more than one reservation happens to a participant's account
+// for the same commitRequestId, this model will need to be updated.
+const getReservedPositionChangesByCommitRequestIds = async (trx, commitRequestIdList) => {
+  try {
+    const knex = await Db.getKnex()
+    const participantPositionChanges = await knex('fxTransferStateChange')
+      .transacting(trx)
+      .whereIn('fxTransferStateChange.commitRequestId', commitRequestIdList)
+      .where('fxTransferStateChange.transferStateId', Enum.Transfers.TransferInternalState.RESERVED)
+      .leftJoin('participantPositionChange AS ppc', 'ppc.fxTransferStateChangeId', 'fxTransferStateChange.fxTransferStateChangeId')
+      .select(
+        'ppc.*',
+        'fxTransferStateChange.commitRequestId AS commitRequestId'
+      )
+    const info = {}
+    for (const participantPositionChange of participantPositionChanges) {
+      if (!(participantPositionChange.commitRequestId in info)) {
+        info[participantPositionChange.commitRequestId] = {}
+      }
+      if (participantPositionChange.participantCurrencyId) {
+        info[participantPositionChange.commitRequestId][participantPositionChange.participantCurrencyId] = participantPositionChange
+      }
+    }
+    return info
+  } catch (err) {
+    Logger.isErrorEnabled && Logger.error(err)
+    throw err
+  }
+}
+
 module.exports = {
   startDbTransaction,
   getLatestTransferStateChangesByTransferIdList,
+  getLatestFxTransferStateChangesByCommitRequestIdList,
   getPositionsByAccountIdsForUpdate,
   updateParticipantPosition,
   bulkInsertTransferStateChanges,
+  bulkInsertFxTransferStateChanges,
   bulkInsertParticipantPositionChanges,
   getAllParticipantCurrency,
   getTransferInfoList,
-  getTransferByIdsForReserve
+  getTransferByIdsForReserve,
+  getFxTransferInfoList,
+  getReservedPositionChangesByCommitRequestIds
 }

package/src/models/position/facade.js

@@ -229,11 +229,13 @@ const prepareChangeParticipantPositionTransaction = async (transferList) => {
         const processedTransfersKeysList = Object.keys(processedTransfers)
         const batchParticipantPositionChange = []
         for (const keyIndex in processedTransfersKeysList) {
-          const { runningPosition, runningReservedValue } = processedTransfers[processedTransfersKeysList[keyIndex]]
+          const { transferAmount, runningPosition, runningReservedValue } = processedTransfers[processedTransfersKeysList[keyIndex]]
           const participantPositionChange = {
             participantPositionId: initialParticipantPosition.participantPositionId,
+            participantCurrencyId: participantCurrency.participantCurrencyId,
             transferStateChangeId: processedTransferStateChangeIdList[keyIndex],
             value: runningPosition,
+            change: transferAmount.toNumber(),
             // processBatch: <uuid> - a single value uuid for this entire batch to make sure the set of transfers in this batch can be clearly grouped
             reservedValue: runningReservedValue
           }
@@ -241,11 +243,9 @@ const prepareChangeParticipantPositionTransaction = async (transferList) => {
         }
         batchParticipantPositionChange.length && await knex.batchInsert('participantPositionChange', batchParticipantPositionChange).transacting(trx)
         histTimerPersistTransferStateChangeEnd({ success: true, queryName: 'facade_prepareChangeParticipantPositionTransaction_transaction_PersistTransferState' })
-        await trx.commit()
         histTimerChangeParticipantPositionTransEnd({ success: true, queryName: 'facade_prepareChangeParticipantPositionTransaction_transaction' })
       } catch (err) {
         Logger.isErrorEnabled && Logger.error(err)
-        await trx.rollback()
         histTimerChangeParticipantPositionTransEnd({ success: false, queryName: 'facade_prepareChangeParticipantPositionTransaction_transaction' })
         throw ErrorHandler.Factory.reformatFSPIOPError(err)
       }
@@ -292,16 +292,16 @@ const changeParticipantPositionTransaction = async (participantCurrencyId, isRev
         const insertedTransferStateChange = await knex('transferStateChange').transacting(trx).where({ transferId: transferStateChange.transferId }).forUpdate().first().orderBy('transferStateChangeId', 'desc')
         const participantPositionChange = {
           participantPositionId: participantPosition.participantPositionId,
+          participantCurrencyId,
           transferStateChangeId: insertedTransferStateChange.transferStateChangeId,
           value: latestPosition,
+          change: isReversal ? -amount : amount,
           reservedValue: participantPosition.reservedValue,
           createdDate: transactionTimestamp
         }
         await knex('participantPositionChange').transacting(trx).insert(participantPositionChange)
-        await trx.commit()
         histTimerChangeParticipantPositionTransactionEnd({ success: true, queryName: 'facade_changeParticipantPositionTransaction' })
       } catch (err) {
-        await trx.rollback()
         throw ErrorHandler.Factory.reformatFSPIOPError(err)
       }
     }).catch((err) => {