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

package/src/models/transfer/facade.js

@@ -23,6 +23,7 @@
  * Rajiv Mothilal <rajiv.mothilal@modusbox.com>
  * Miguel de Barros <miguel.debarros@modusbox.com>
  * Shashikant Hirugade <shashikant.hirugade@modusbox.com>
+ * Vijay Kumar Guthi <vijaya.guthi@infitx.com>
  --------------
  ******/
 
@@ -32,19 +33,21 @@
  * @module src/models/transfer/facade/
  */
 
-const Db = require('../../lib/db')
+const ErrorHandler = require('@mojaloop/central-services-error-handling')
+const Metrics = require('@mojaloop/central-services-metrics')
+const MLNumber = require('@mojaloop/ml-number')
 const Enum = require('@mojaloop/central-services-shared').Enum
-const TransferEventAction = Enum.Events.Event.Action
-const TransferInternalState = Enum.Transfers.TransferInternalState
-const TransferExtensionModel = require('./transferExtension')
-const ParticipantFacade = require('../participant/facade')
 const Time = require('@mojaloop/central-services-shared').Util.Time
-const MLNumber = require('@mojaloop/ml-number')
+
+const { logger } = require('../../shared/logger')
+const Db = require('../../lib/db')
 const Config = require('../../lib/config')
-const _ = require('lodash')
-const ErrorHandler = require('@mojaloop/central-services-error-handling')
-const Logger = require('@mojaloop/central-services-logger')
-const Metrics = require('@mojaloop/central-services-metrics')
+const ParticipantFacade = require('../participant/facade')
+const ParticipantCachedModel = require('../participant/participantCached')
+const TransferExtensionModel = require('./transferExtension')
+
+const TransferEventAction = Enum.Events.Event.Action
+const TransferInternalState = Enum.Transfers.TransferInternalState
 
 // Alphabetically ordered list of error texts used below
 const UnsupportedActionText = 'Unsupported action'
@@ -53,24 +56,25 @@ const getById = async (id) => {
   try {
     /** @namespace Db.transfer **/
     return await Db.from('transfer').query(async (builder) => {
+      /* istanbul ignore next */
       const transferResult = await builder
         .where({
           'transfer.transferId': id,
           'tprt1.name': 'PAYER_DFSP', // TODO: refactor to use transferParticipantRoleTypeId
           'tprt2.name': 'PAYEE_DFSP'
         })
-        .whereRaw('pc1.currencyId = transfer.currencyId')
-        .whereRaw('pc2.currencyId = transfer.currencyId')
         // PAYER
         .innerJoin('transferParticipant AS tp1', 'tp1.transferId', 'transfer.transferId')
+        .leftJoin('externalParticipant AS ep1', 'ep1.externalParticipantId', 'tp1.externalParticipantId')
         .innerJoin('transferParticipantRoleType AS tprt1', 'tprt1.transferParticipantRoleTypeId', 'tp1.transferParticipantRoleTypeId')
-        .innerJoin('participantCurrency AS pc1', 'pc1.participantCurrencyId', 'tp1.participantCurrencyId')
-        .innerJoin('participant AS da', 'da.participantId', 'pc1.participantId')
+        .innerJoin('participant AS da', 'da.participantId', 'tp1.participantId')
+        .leftJoin('participantCurrency AS pc1', 'pc1.participantCurrencyId', 'tp1.participantCurrencyId')
         // PAYEE
         .innerJoin('transferParticipant AS tp2', 'tp2.transferId', 'transfer.transferId')
+        .leftJoin('externalParticipant AS ep2', 'ep2.externalParticipantId', 'tp2.externalParticipantId')
         .innerJoin('transferParticipantRoleType AS tprt2', 'tprt2.transferParticipantRoleTypeId', 'tp2.transferParticipantRoleTypeId')
-        .innerJoin('participantCurrency AS pc2', 'pc2.participantCurrencyId', 'tp2.participantCurrencyId')
-        .innerJoin('participant AS ca', 'ca.participantId', 'pc2.participantId')
+        .innerJoin('participant AS ca', 'ca.participantId', 'tp2.participantId')
+        .leftJoin('participantCurrency AS pc2', 'pc2.participantCurrencyId', 'tp2.participantCurrencyId')
         // OTHER JOINS
         .innerJoin('ilpPacket AS ilpp', 'ilpp.transferId', 'transfer.transferId')
         .leftJoin('transferStateChange AS tsc', 'tsc.transferId', 'transfer.transferId')
@@ -84,10 +88,12 @@ const getById = async (id) => {
           'tp1.amount AS payerAmount',
           'da.participantId AS payerParticipantId',
           'da.name AS payerFsp',
+          'da.isProxy AS payerIsProxy',
           'pc2.participantCurrencyId AS payeeParticipantCurrencyId',
           'tp2.amount AS payeeAmount',
           'ca.participantId AS payeeParticipantId',
           'ca.name AS payeeFsp',
+          'ca.isProxy AS payeeIsProxy',
           'tsc.transferStateChangeId',
           'tsc.transferStateId AS transferState',
           'tsc.reason AS reason',
@@ -98,10 +104,13 @@ const getById = async (id) => {
           'transfer.ilpCondition AS condition',
           'tf.ilpFulfilment AS fulfilment',
           'te.errorCode',
-          'te.errorDescription'
+          'te.errorDescription',
+          'ep1.name AS externalPayerName',
+          'ep2.name AS externalPayeeName'
         )
         .orderBy('tsc.transferStateChangeId', 'desc')
         .first()
+
       if (transferResult) {
         transferResult.extensionList = await TransferExtensionModel.getByTransferId(id) // TODO: check if this is needed
         if (transferResult.errorCode && transferResult.transferStateEnumeration === Enum.Transfers.TransferState.ABORTED) {
@@ -116,6 +125,7 @@ const getById = async (id) => {
       return transferResult
     })
   } catch (err) {
+    logger.warn('error in transfer.getById', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -168,6 +178,7 @@ const getByIdLight = async (id) => {
       return transferResult
     })
   } catch (err) {
+    logger.warn('error in transfer.getByIdLight', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -222,6 +233,7 @@ const getAll = async () => {
       return transferResultList
     })
   } catch (err) {
+    logger.warn('error in transfer.getAll', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -237,8 +249,10 @@ const getTransferInfoToChangePosition = async (id, transferParticipantRoleTypeId
           'transferParticipant.ledgerEntryTypeId': ledgerEntryTypeId
         })
         .innerJoin('transferStateChange AS tsc', 'tsc.transferId', 'transferParticipant.transferId')
+        .innerJoin('transfer AS t', 't.transferId', 'transferParticipant.transferId')
         .select(
           'transferParticipant.*',
+          't.currencyId',
           'tsc.transferStateId',
           'tsc.reason'
         )
@@ -246,6 +260,7 @@ const getTransferInfoToChangePosition = async (id, transferParticipantRoleTypeId
         .first()
     })
   } catch (err) {
+    logger.warn('error in getTransferInfoToChangePosition', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -353,12 +368,12 @@ const savePayeeTransferResponse = async (transferId, payload, action, fspiopErro
               .orderBy('changedDate', 'desc')
           })
           transferFulfilmentRecord.settlementWindowId = res[0].settlementWindowId
-          Logger.isDebugEnabled && Logger.debug('savePayeeTransferResponse::settlementWindowId')
+          logger.debug('savePayeeTransferResponse::settlementWindowId')
         }
         if (isFulfilment) {
           await knex('transferFulfilment').transacting(trx).insert(transferFulfilmentRecord)
           result.transferFulfilmentRecord = transferFulfilmentRecord
-          Logger.isDebugEnabled && Logger.debug('savePayeeTransferResponse::transferFulfilment')
+          logger.debug('savePayeeTransferResponse::transferFulfilment')
         }
         if (transferExtensionRecordsList.length > 0) {
           // ###! CAN BE DONE THROUGH A BATCH
@@ -367,11 +382,11 @@ const savePayeeTransferResponse = async (transferId, payload, action, fspiopErro
           }
           // ###!
           result.transferExtensionRecordsList = transferExtensionRecordsList
-          Logger.isDebugEnabled && Logger.debug('savePayeeTransferResponse::transferExtensionRecordsList')
+          logger.debug('savePayeeTransferResponse::transferExtensionRecordsList')
         }
         await knex('transferStateChange').transacting(trx).insert(transferStateChangeRecord)
         result.transferStateChangeRecord = transferStateChangeRecord
-        Logger.isDebugEnabled && Logger.debug('savePayeeTransferResponse::transferStateChange')
+        logger.debug('savePayeeTransferResponse::transferStateChange')
         if (fspiopError) {
           const insertedTransferStateChange = await knex('transferStateChange').transacting(trx)
             .where({ transferId })
@@ -380,45 +395,81 @@ const savePayeeTransferResponse = async (transferId, payload, action, fspiopErro
           transferErrorRecord.transferStateChangeId = insertedTransferStateChange.transferStateChangeId
           await knex('transferError').transacting(trx).insert(transferErrorRecord)
           result.transferErrorRecord = transferErrorRecord
-          Logger.isDebugEnabled && Logger.debug('savePayeeTransferResponse::transferError')
+          logger.debug('savePayeeTransferResponse::transferError')
         }
         histTPayeeResponseValidationPassedEnd({ success: true, queryName: 'facade_saveTransferPrepared_transaction' })
         result.savePayeeTransferResponseExecuted = true
-        Logger.isDebugEnabled && Logger.debug('savePayeeTransferResponse::success')
+        logger.debug('savePayeeTransferResponse::success')
       } catch (err) {
-        await trx.rollback()
+        logger.error('savePayeeTransferResponse::failure', err)
         histTPayeeResponseValidationPassedEnd({ success: false, queryName: 'facade_saveTransferPrepared_transaction' })
-        Logger.isErrorEnabled && Logger.error('savePayeeTransferResponse::failure')
         throw err
       }
     })
     histTimerSavePayeeTranferResponsedEnd({ success: true, queryName: 'facade_savePayeeTransferResponse' })
     return result
   } catch (err) {
+    logger.warn('error in savePayeeTransferResponse', err)
     histTimerSavePayeeTranferResponsedEnd({ success: false, queryName: 'facade_savePayeeTransferResponse' })
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
 
-const saveTransferPrepared = async (payload, stateReason = null, hasPassedValidation = true) => {
+/**
+ * Saves prepare transfer details to DB.
+ *
+ * @param {Object} payload - Message payload.
+ * @param {string | null} stateReason - Validation failure reasons.
+ * @param {Boolean} hasPassedValidation - Is transfer prepare validation passed.
+ * @param {DeterminingTransferCheckResult} determiningTransferCheckResult - Determining transfer check result.
+ * @param {ProxyObligation} proxyObligation - The proxy obligation
+ * @returns {Promise<void>}
+ */
+const saveTransferPrepared = async (payload, stateReason = null, hasPassedValidation = true, determiningTransferCheckResult, proxyObligation) => {
   const histTimerSaveTransferPreparedEnd = Metrics.getHistogram(
     'model_transfer',
     'facade_saveTransferPrepared - Metrics for transfer model',
     ['success', 'queryName']
   ).startTimer()
   try {
-    const participants = []
-    const names = [payload.payeeFsp, payload.payerFsp]
+    const participants = {
+      [payload.payeeFsp]: {},
+      [payload.payerFsp]: {}
+    }
 
-    for (const name of names) {
-      const participant = await ParticipantFacade.getByNameAndCurrency(name, payload.amount.currency, Enum.Accounts.LedgerAccountType.POSITION)
+    // Iterate over the participants and get the details
+    for (const name of Object.keys(participants)) {
+      const participant = await ParticipantCachedModel.getByName(name)
       if (participant) {
-        participants.push(participant)
+        participants[name].id = participant.participantId
+      }
+      // If determiningTransferCheckResult.participantCurrencyValidationList contains the participant name, then get the participantCurrencyId
+      const participantCurrency = determiningTransferCheckResult && determiningTransferCheckResult.participantCurrencyValidationList.find(participantCurrencyItem => participantCurrencyItem.participantName === name)
+      if (participantCurrency) {
+        const participantCurrencyRecord = await ParticipantFacade.getByNameAndCurrency(participantCurrency.participantName, participantCurrency.currencyId, Enum.Accounts.LedgerAccountType.POSITION)
+        participants[name].participantCurrencyId = participantCurrencyRecord?.participantCurrencyId
       }
     }
 
-    const participantCurrencyIds = await _.reduce(participants, (m, acct) =>
-      _.set(m, acct.name, acct.participantCurrencyId), {})
+    if (proxyObligation?.isInitiatingFspProxy) {
+      const proxyId = proxyObligation.initiatingFspProxyOrParticipantId.proxyId
+      const proxyParticipant = await ParticipantCachedModel.getByName(proxyId)
+      participants[proxyId] = {}
+      participants[proxyId].id = proxyParticipant.participantId
+      const participantCurrencyRecord = await ParticipantFacade.getByNameAndCurrency(
+        proxyId, payload.amount.currency, Enum.Accounts.LedgerAccountType.POSITION
+      )
+      // In a regional scheme, the stand-in initiating FSP proxy may not have a participantCurrencyId
+      // of the target currency of the transfer, so set to null if not found
+      participants[proxyId].participantCurrencyId = participantCurrencyRecord?.participantCurrencyId
+    }
+
+    if (proxyObligation?.isCounterPartyFspProxy) {
+      const proxyId = proxyObligation.counterPartyFspProxyOrParticipantId.proxyId
+      const proxyParticipant = await ParticipantCachedModel.getByName(proxyId)
+      participants[proxyId] = {}
+      participants[proxyId].id = proxyParticipant.participantId
+    }
 
     const transferRecord = {
       transferId: payload.transferId,
@@ -433,29 +484,60 @@ const saveTransferPrepared = async (payload, stateReason = null, hasPassedValida
       value: payload.ilpPacket
     }
 
-    const state = ((hasPassedValidation) ? Enum.Transfers.TransferInternalState.RECEIVED_PREPARE : Enum.Transfers.TransferInternalState.INVALID)
-
     const transferStateChangeRecord = {
       transferId: payload.transferId,
-      transferStateId: state,
+      transferStateId: hasPassedValidation ? TransferInternalState.RECEIVED_PREPARE : TransferInternalState.INVALID,
       reason: stateReason,
       createdDate: Time.getUTCString(new Date())
     }
 
-    const payerTransferParticipantRecord = {
-      transferId: payload.transferId,
-      participantCurrencyId: participantCurrencyIds[payload.payerFsp],
-      transferParticipantRoleTypeId: Enum.Accounts.TransferParticipantRoleType.PAYER_DFSP,
-      ledgerEntryTypeId: Enum.Accounts.LedgerEntryType.PRINCIPLE_VALUE,
-      amount: payload.amount.amount
+    let payerTransferParticipantRecord
+    if (proxyObligation?.isInitiatingFspProxy) {
+      const externalParticipantId = await ParticipantFacade.getExternalParticipantIdByNameOrCreate(proxyObligation.initiatingFspProxyOrParticipantId)
+      // todo: think, what if externalParticipantId is null?
+      payerTransferParticipantRecord = {
+        transferId: payload.transferId,
+        participantId: participants[proxyObligation.initiatingFspProxyOrParticipantId.proxyId].id,
+        participantCurrencyId: participants[proxyObligation.initiatingFspProxyOrParticipantId.proxyId].participantCurrencyId,
+        transferParticipantRoleTypeId: Enum.Accounts.TransferParticipantRoleType.PAYER_DFSP,
+        ledgerEntryTypeId: Enum.Accounts.LedgerEntryType.PRINCIPLE_VALUE,
+        amount: -payload.amount.amount,
+        externalParticipantId
+      }
+    } else {
+      payerTransferParticipantRecord = {
+        transferId: payload.transferId,
+        participantId: participants[payload.payerFsp].id,
+        participantCurrencyId: participants[payload.payerFsp].participantCurrencyId,
+        transferParticipantRoleTypeId: Enum.Accounts.TransferParticipantRoleType.PAYER_DFSP,
+        ledgerEntryTypeId: Enum.Accounts.LedgerEntryType.PRINCIPLE_VALUE,
+        amount: payload.amount.amount
+      }
     }
 
-    const payeeTransferParticipantRecord = {
-      transferId: payload.transferId,
-      participantCurrencyId: participantCurrencyIds[payload.payeeFsp],
-      transferParticipantRoleTypeId: Enum.Accounts.TransferParticipantRoleType.PAYEE_DFSP,
-      ledgerEntryTypeId: Enum.Accounts.LedgerEntryType.PRINCIPLE_VALUE,
-      amount: -payload.amount.amount
+    logger.debug('saveTransferPrepared participants:', { participants })
+    let payeeTransferParticipantRecord
+    if (proxyObligation?.isCounterPartyFspProxy) {
+      const externalParticipantId = await ParticipantFacade.getExternalParticipantIdByNameOrCreate(proxyObligation.counterPartyFspProxyOrParticipantId)
+      // todo: think, what if externalParticipantId is null?
+      payeeTransferParticipantRecord = {
+        transferId: payload.transferId,
+        participantId: participants[proxyObligation.counterPartyFspProxyOrParticipantId.proxyId].id,
+        participantCurrencyId: null,
+        transferParticipantRoleTypeId: Enum.Accounts.TransferParticipantRoleType.PAYEE_DFSP,
+        ledgerEntryTypeId: Enum.Accounts.LedgerEntryType.PRINCIPLE_VALUE,
+        amount: -payload.amount.amount,
+        externalParticipantId
+      }
+    } else {
+      payeeTransferParticipantRecord = {
+        transferId: payload.transferId,
+        participantId: participants[payload.payeeFsp].id,
+        participantCurrencyId: participants[payload.payeeFsp].participantCurrencyId,
+        transferParticipantRoleTypeId: Enum.Accounts.TransferParticipantRoleType.PAYEE_DFSP,
+        ledgerEntryTypeId: Enum.Accounts.LedgerEntryType.PRINCIPLE_VALUE,
+        amount: -payload.amount.amount
+      }
     }
 
     const knex = await Db.getKnex()
@@ -485,10 +567,8 @@ const saveTransferPrepared = async (payload, stateReason = null, hasPassedValida
           }
           await knex('ilpPacket').transacting(trx).insert(ilpPacketRecord)
           await knex('transferStateChange').transacting(trx).insert(transferStateChangeRecord)
-          await trx.commit()
           histTimerSaveTranferTransactionValidationPassedEnd({ success: true, queryName: 'facade_saveTransferPrepared_transaction' })
         } catch (err) {
-          await trx.rollback()
           histTimerSaveTranferTransactionValidationPassedEnd({ success: false, queryName: 'facade_saveTransferPrepared_transaction' })
           throw err
         }
@@ -503,14 +583,14 @@ const saveTransferPrepared = async (payload, stateReason = null, hasPassedValida
       try {
         await knex('transferParticipant').insert(payerTransferParticipantRecord)
       } catch (err) {
-        Logger.isWarnEnabled && Logger.warn(`Payer transferParticipant insert error: ${err.message}`)
+        logger.warn('Payer transferParticipant insert error', err)
         histTimerSaveTranferNoValidationEnd({ success: false, queryName: 'facade_saveTransferPrepared_no_validation' })
       }
       try {
         await knex('transferParticipant').insert(payeeTransferParticipantRecord)
       } catch (err) {
+        logger.warn('Payee transferParticipant insert error:', err)
         histTimerSaveTranferNoValidationEnd({ success: false, queryName: 'facade_saveTransferPrepared_no_validation' })
-        Logger.isWarnEnabled && Logger.warn(`Payee transferParticipant insert error: ${err.message}`)
       }
       payerTransferParticipantRecord.name = payload.payerFsp
       payeeTransferParticipantRecord.name = payload.payeeFsp
@@ -526,26 +606,27 @@ const saveTransferPrepared = async (payload, stateReason = null, hasPassedValida
         try {
           await knex.batchInsert('transferExtension', transferExtensionsRecordList)
         } catch (err) {
-          Logger.isWarnEnabled && Logger.warn(`batchInsert transferExtension error: ${err.message}`)
+          logger.warn('batchInsert transferExtension error:', err)
           histTimerSaveTranferNoValidationEnd({ success: false, queryName: 'facade_saveTransferPrepared_no_validation' })
         }
       }
       try {
         await knex('ilpPacket').insert(ilpPacketRecord)
       } catch (err) {
-        Logger.isWarnEnabled && Logger.warn(`ilpPacket insert error: ${err.message}`)
+        logger.warn('ilpPacket insert error:', err)
         histTimerSaveTranferNoValidationEnd({ success: false, queryName: 'facade_saveTransferPrepared_no_validation' })
       }
       try {
         await knex('transferStateChange').insert(transferStateChangeRecord)
         histTimerSaveTranferNoValidationEnd({ success: true, queryName: 'facade_saveTransferPrepared_no_validation' })
       } catch (err) {
-        Logger.isWarnEnabled && Logger.warn(`transferStateChange insert error: ${err.message}`)
+        logger.warn('transferStateChange insert error:', err)
         histTimerSaveTranferNoValidationEnd({ success: false, queryName: 'facade_saveTransferPrepared_no_validation' })
       }
     }
     histTimerSaveTransferPreparedEnd({ success: true, queryName: 'transfer_model_facade_saveTransferPrepared' })
   } catch (err) {
+    logger.warn('error in saveTransferPrepared', err)
     histTimerSaveTransferPreparedEnd({ success: false, queryName: 'transfer_model_facade_saveTransferPrepared' })
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
@@ -592,7 +673,265 @@ const getTransferStateByTransferId = async (id) => {
   }
 }
 
-const timeoutExpireReserved = async (segmentId, intervalMin, intervalMax) => {
+const _processTimeoutEntries = async (knex, trx, transactionTimestamp) => {
+  // Insert `transferStateChange` records for RECEIVED_PREPARE
+  await knex.from(knex.raw('transferStateChange (transferId, transferStateId, reason)')).transacting(trx)
+    .insert(function () {
+      this.from('transferTimeout AS tt')
+        .innerJoin(knex('transferStateChange AS tsc1')
+          .select('tsc1.transferId')
+          .max('tsc1.transferStateChangeId AS maxTransferStateChangeId')
+          .innerJoin('transferTimeout AS tt1', 'tt1.transferId', 'tsc1.transferId')
+          .groupBy('tsc1.transferId').as('ts'), 'ts.transferId', 'tt.transferId'
+        )
+        .innerJoin('transferStateChange AS tsc', 'tsc.transferStateChangeId', 'ts.maxTransferStateChangeId')
+        .where('tt.expirationDate', '<', transactionTimestamp)
+        .andWhere('tsc.transferStateId', `${Enum.Transfers.TransferInternalState.RECEIVED_PREPARE}`)
+        .select('tt.transferId', knex.raw('?', Enum.Transfers.TransferInternalState.EXPIRED_PREPARED), knex.raw('?', 'Aborted by Timeout Handler'))
+    })
+
+  // Insert `transferStateChange` records for RESERVED
+  await knex.from(knex.raw('transferStateChange (transferId, transferStateId, reason)')).transacting(trx)
+    .insert(function () {
+      this.from('transferTimeout AS tt')
+        .innerJoin(knex('transferStateChange AS tsc1')
+          .select('tsc1.transferId')
+          .max('tsc1.transferStateChangeId AS maxTransferStateChangeId')
+          .innerJoin('transferTimeout AS tt1', 'tt1.transferId', 'tsc1.transferId')
+          .groupBy('tsc1.transferId').as('ts'), 'ts.transferId', 'tt.transferId'
+        )
+        .innerJoin('transferStateChange AS tsc', 'tsc.transferStateChangeId', 'ts.maxTransferStateChangeId')
+        .where('tt.expirationDate', '<', transactionTimestamp)
+        .andWhere('tsc.transferStateId', `${Enum.Transfers.TransferState.RESERVED}`)
+        .select('tt.transferId', knex.raw('?', Enum.Transfers.TransferInternalState.RESERVED_TIMEOUT), knex.raw('?', 'Marked for expiration by Timeout Handler'))
+    })
+}
+
+const _insertTransferErrorEntries = async (knex, trx, transactionTimestamp) => {
+  // Insert `transferError` records
+  await knex.from(knex.raw('transferError (transferId, transferStateChangeId, errorCode, errorDescription)')).transacting(trx)
+    .insert(function () {
+      this.from('transferTimeout AS tt')
+        .innerJoin(knex('transferStateChange AS tsc1')
+          .select('tsc1.transferId')
+          .max('tsc1.transferStateChangeId AS maxTransferStateChangeId')
+          .innerJoin('transferTimeout AS tt1', 'tt1.transferId', 'tsc1.transferId')
+          .groupBy('tsc1.transferId').as('ts'), 'ts.transferId', 'tt.transferId'
+        )
+        .innerJoin('transferStateChange AS tsc', 'tsc.transferStateChangeId', 'ts.maxTransferStateChangeId')
+        .where('tt.expirationDate', '<', transactionTimestamp)
+        .andWhere('tsc.transferStateId', `${Enum.Transfers.TransferInternalState.RESERVED_TIMEOUT}`)
+        .select('tt.transferId', 'tsc.transferStateChangeId', knex.raw('?', ErrorHandler.Enums.FSPIOPErrorCodes.TRANSFER_EXPIRED.code), knex.raw('?', ErrorHandler.Enums.FSPIOPErrorCodes.TRANSFER_EXPIRED.message))
+    })
+}
+
+const _processFxTimeoutEntries = async (knex, trx, transactionTimestamp) => {
+  // Insert `fxTransferStateChange` records for RECEIVED_PREPARE
+  /* istanbul ignore next */
+  await knex.from(knex.raw('fxTransferStateChange (commitRequestId, transferStateId, reason)')).transacting(trx)
+    .insert(function () {
+      this.from('fxTransferTimeout AS ftt')
+        .innerJoin(knex('fxTransferStateChange AS ftsc1')
+          .select('ftsc1.commitRequestId')
+          .max('ftsc1.fxTransferStateChangeId AS maxFxTransferStateChangeId')
+          .innerJoin('fxTransferTimeout AS ftt1', 'ftt1.commitRequestId', 'ftsc1.commitRequestId')
+          .groupBy('ftsc1.commitRequestId').as('fts'), 'fts.commitRequestId', 'ftt.commitRequestId'
+        )
+        .innerJoin('fxTransferStateChange AS ftsc', 'ftsc.fxTransferStateChangeId', 'fts.maxFxTransferStateChangeId')
+        .where('ftt.expirationDate', '<', transactionTimestamp)
+        .andWhere('ftsc.transferStateId', `${Enum.Transfers.TransferInternalState.RECEIVED_PREPARE}`)
+        .select('ftt.commitRequestId', knex.raw('?', Enum.Transfers.TransferInternalState.EXPIRED_PREPARED), knex.raw('?', 'Aborted by Timeout Handler'))
+    })
+
+  // Insert `fxTransferStateChange` records for RESERVED
+  await knex.from(knex.raw('fxTransferStateChange (commitRequestId, transferStateId, reason)')).transacting(trx)
+    .insert(function () {
+      this.from('fxTransferTimeout AS ftt')
+        .innerJoin(knex('fxTransferStateChange AS ftsc1')
+          .select('ftsc1.commitRequestId')
+          .max('ftsc1.fxTransferStateChangeId AS maxFxTransferStateChangeId')
+          .innerJoin('fxTransferTimeout AS ftt1', 'ftt1.commitRequestId', 'ftsc1.commitRequestId')
+          .groupBy('ftsc1.commitRequestId').as('fts'), 'fts.commitRequestId', 'ftt.commitRequestId'
+        )
+        .innerJoin('fxTransferStateChange AS ftsc', 'ftsc.fxTransferStateChangeId', 'fts.maxFxTransferStateChangeId')
+        .where('ftt.expirationDate', '<', transactionTimestamp)
+        .andWhere('ftsc.transferStateId', `${Enum.Transfers.TransferState.RESERVED}`)
+        .select('ftt.commitRequestId', knex.raw('?', Enum.Transfers.TransferInternalState.RESERVED_TIMEOUT), knex.raw('?', 'Marked for expiration by Timeout Handler'))
+    })
+
+  // Insert `fxTransferStateChange` records for RECEIVED_FULFIL_DEPENDENT
+  await knex.from(knex.raw('fxTransferStateChange (commitRequestId, transferStateId, reason)')).transacting(trx)
+    .insert(function () {
+      this.from('fxTransferTimeout AS ftt')
+        .innerJoin(knex('fxTransferStateChange AS ftsc1')
+          .select('ftsc1.commitRequestId')
+          .max('ftsc1.fxTransferStateChangeId AS maxFxTransferStateChangeId')
+          .innerJoin('fxTransferTimeout AS ftt1', 'ftt1.commitRequestId', 'ftsc1.commitRequestId')
+          .groupBy('ftsc1.commitRequestId').as('fts'), 'fts.commitRequestId', 'ftt.commitRequestId'
+        )
+        .innerJoin('fxTransferStateChange AS ftsc', 'ftsc.fxTransferStateChangeId', 'fts.maxFxTransferStateChangeId')
+        .where('ftt.expirationDate', '<', transactionTimestamp)
+        .andWhere('ftsc.transferStateId', `${Enum.Transfers.TransferInternalState.RECEIVED_FULFIL_DEPENDENT}`)
+        .select('ftt.commitRequestId', knex.raw('?', Enum.Transfers.TransferInternalState.RESERVED_TIMEOUT), knex.raw('?', 'Marked for expiration by Timeout Handler'))
+    })
+}
+
+const _insertFxTransferErrorEntries = async (knex, trx, transactionTimestamp) => {
+  // Insert `fxTransferError` records
+  await knex.from(knex.raw('fxTransferError (commitRequestId, fxTransferStateChangeId, errorCode, errorDescription)')).transacting(trx)
+    .insert(function () {
+      this.from('fxTransferTimeout AS ftt')
+        .innerJoin(knex('fxTransferStateChange AS ftsc1')
+          .select('ftsc1.commitRequestId')
+          .max('ftsc1.fxTransferStateChangeId AS maxFxTransferStateChangeId')
+          .innerJoin('fxTransferTimeout AS ftt1', 'ftt1.commitRequestId', 'ftsc1.commitRequestId')
+          .groupBy('ftsc1.commitRequestId').as('fts'), 'fts.commitRequestId', 'ftt.commitRequestId'
+        )
+        .innerJoin('fxTransferStateChange AS ftsc', 'ftsc.fxTransferStateChangeId', 'fts.maxFxTransferStateChangeId')
+        .where('ftt.expirationDate', '<', transactionTimestamp)
+        .andWhere('ftsc.transferStateId', `${Enum.Transfers.TransferInternalState.RESERVED_TIMEOUT}`)
+        .select('ftt.commitRequestId', 'ftsc.fxTransferStateChangeId', knex.raw('?', ErrorHandler.Enums.FSPIOPErrorCodes.TRANSFER_EXPIRED.code), knex.raw('?', ErrorHandler.Enums.FSPIOPErrorCodes.TRANSFER_EXPIRED.message))
+    })
+}
+
+const _getTransferTimeoutList = async (knex, transactionTimestamp) => {
+  /* istanbul ignore next */
+  return knex('transferTimeout AS tt')
+    .innerJoin(knex('transferStateChange AS tsc1')
+      .select('tsc1.transferId')
+      .max('tsc1.transferStateChangeId AS maxTransferStateChangeId')
+      .innerJoin('transferTimeout AS tt1', 'tt1.transferId', 'tsc1.transferId')
+      .groupBy('tsc1.transferId')
+      .as('ts'), 'ts.transferId', 'tt.transferId'
+    )
+    .innerJoin('transferStateChange AS tsc', 'tsc.transferStateChangeId', 'ts.maxTransferStateChangeId')
+    .innerJoin('transferParticipant AS tp1', function () {
+      this.on('tp1.transferId', 'tt.transferId')
+        .andOn('tp1.transferParticipantRoleTypeId', Enum.Accounts.TransferParticipantRoleType.PAYER_DFSP)
+        .andOn('tp1.ledgerEntryTypeId', Enum.Accounts.LedgerEntryType.PRINCIPLE_VALUE)
+    })
+    .leftJoin('externalParticipant AS ep1', 'ep1.externalParticipantId', 'tp1.externalParticipantId')
+    .innerJoin('transferParticipant AS tp2', function () {
+      this.on('tp2.transferId', 'tt.transferId')
+        .andOn('tp2.transferParticipantRoleTypeId', Enum.Accounts.TransferParticipantRoleType.PAYEE_DFSP)
+        .andOn('tp2.ledgerEntryTypeId', Enum.Accounts.LedgerEntryType.PRINCIPLE_VALUE)
+    })
+    .leftJoin('externalParticipant AS ep2', 'ep2.externalParticipantId', 'tp2.externalParticipantId')
+    .innerJoin('participant AS p1', 'p1.participantId', 'tp1.participantId')
+    .innerJoin('participant AS p2', 'p2.participantId', 'tp2.participantId')
+    .innerJoin(knex('transferStateChange AS tsc2')
+      .select('tsc2.transferId', 'tsc2.transferStateChangeId', 'ppc1.participantCurrencyId')
+      .innerJoin('transferTimeout AS tt2', 'tt2.transferId', 'tsc2.transferId')
+      .innerJoin('participantPositionChange AS ppc1', 'ppc1.transferStateChangeId', 'tsc2.transferStateChangeId')
+      .as('tpc'), 'tpc.transferId', 'tt.transferId'
+    )
+    .leftJoin('bulkTransferAssociation AS bta', 'bta.transferId', 'tt.transferId')
+
+    .where('tt.expirationDate', '<', transactionTimestamp)
+    .select(
+      'tt.*',
+      'tsc.transferStateId',
+      'tp1.participantCurrencyId AS payerParticipantCurrencyId',
+      'p1.name AS payerFsp',
+      'p2.name AS payeeFsp',
+      'tp2.participantCurrencyId AS payeeParticipantCurrencyId',
+      'bta.bulkTransferId',
+      'tpc.participantCurrencyId AS effectedParticipantCurrencyId',
+      'ep1.name AS externalPayerName',
+      'ep2.name AS externalPayeeName'
+    )
+}
+
+const _getFxTransferTimeoutList = async (knex, transactionTimestamp) => {
+  /* istanbul ignore next */
+  return knex('fxTransferTimeout AS ftt')
+    .innerJoin(knex('fxTransferStateChange AS ftsc1')
+      .select('ftsc1.commitRequestId')
+      .max('ftsc1.fxTransferStateChangeId AS maxFxTransferStateChangeId')
+      .innerJoin('fxTransferTimeout AS ftt1', 'ftt1.commitRequestId', 'ftsc1.commitRequestId')
+      .groupBy('ftsc1.commitRequestId')
+      .as('fts'), 'fts.commitRequestId', 'ftt.commitRequestId'
+    )
+    .innerJoin('fxTransferStateChange AS ftsc', 'ftsc.fxTransferStateChangeId', 'fts.maxFxTransferStateChangeId')
+    .innerJoin('fxTransferParticipant AS ftp1', function () {
+      this.on('ftp1.commitRequestId', 'ftt.commitRequestId')
+        .andOn('ftp1.transferParticipantRoleTypeId', Enum.Accounts.TransferParticipantRoleType.INITIATING_FSP)
+        .andOn('ftp1.ledgerEntryTypeId', Enum.Accounts.LedgerEntryType.PRINCIPLE_VALUE)
+    })
+    .leftJoin('externalParticipant AS ep1', 'ep1.externalParticipantId', 'ftp1.externalParticipantId')
+    .innerJoin('fxTransferParticipant AS ftp2', function () {
+      this.on('ftp2.commitRequestId', 'ftt.commitRequestId')
+        .andOn('ftp2.transferParticipantRoleTypeId', Enum.Accounts.TransferParticipantRoleType.COUNTER_PARTY_FSP)
+        .andOn('ftp2.fxParticipantCurrencyTypeId', Enum.Fx.FxParticipantCurrencyType.TARGET)
+        .andOn('ftp2.ledgerEntryTypeId', Enum.Accounts.LedgerEntryType.PRINCIPLE_VALUE)
+    })
+    .leftJoin('externalParticipant AS ep2', 'ep2.externalParticipantId', 'ftp2.externalParticipantId')
+    .innerJoin('participant AS p1', 'p1.participantId', 'ftp1.participantId')
+    .innerJoin('participant AS p2', 'p2.participantId', 'ftp2.participantId')
+    .innerJoin(knex('fxTransferStateChange AS ftsc2')
+      .select('ftsc2.commitRequestId', 'ftsc2.fxTransferStateChangeId', 'ppc1.participantCurrencyId')
+      .innerJoin('fxTransferTimeout AS ftt2', 'ftt2.commitRequestId', 'ftsc2.commitRequestId')
+      .innerJoin('participantPositionChange AS ppc1', 'ppc1.fxTransferStateChangeId', 'ftsc2.fxTransferStateChangeId')
+      .as('ftpc'), 'ftpc.commitRequestId', 'ftt.commitRequestId'
+    )
+    .where('ftt.expirationDate', '<', transactionTimestamp)
+    .select(
+      'ftt.*',
+      'ftsc.transferStateId',
+      'ftp1.participantCurrencyId AS initiatingParticipantCurrencyId',
+      'p1.name AS initiatingFsp',
+      'p2.name AS counterPartyFsp',
+      'ftp2.participantCurrencyId AS counterPartyParticipantCurrencyId',
+      'ftpc.participantCurrencyId AS effectedParticipantCurrencyId',
+      'ep1.name AS externalInitiatingFspName',
+      'ep2.name AS externalCounterPartyFspName'
+    )
+}
+
+/**
+ * @typedef {Object} TimedOutTransfer
+ *
+ * @property {Integer} transferTimeoutId
+ * @property {String} transferId
+ * @property {Date} expirationDate
+ * @property {Date} createdDate
+ * @property {String} transferStateId
+ * @property {String} payerFsp
+ * @property {String} payeeFsp
+ * @property {Integer} payerParticipantCurrencyId
+ * @property {Integer} payeeParticipantCurrencyId
+ * @property {Integer} bulkTransferId
+ * @property {Integer} effectedParticipantCurrencyId
+ * @property {String} externalPayerName
+ * @property {String} externalPayeeName
+ */
+
+/**
+ * @typedef {Object} TimedOutFxTransfer
+ *
+ * @property {Integer} fxTransferTimeoutId
+ * @property {String} commitRequestId
+ * @property {Date} expirationDate
+ * @property {Date} createdDate
+ * @property {String} transferStateId
+ * @property {String} initiatingFsp
+ * @property {String} counterPartyFsp
+ * @property {Integer} initiatingParticipantCurrencyId
+ * @property {Integer} counterPartyParticipantCurrencyId
+ * @property {Integer} effectedParticipantCurrencyId
+ * @property {String} externalInitiatingFspName
+ * @property {String} externalCounterPartyFspName
+ */
+
+/**
+ *  Returns the list of transfers/fxTransfers that have timed out
+ *
+ * @returns {Promise<{
+ *    transferTimeoutList: TimedOutTransfer,
+ *    fxTransferTimeoutList: TimedOutFxTransfer
+ * }>}
+ */
+const timeoutExpireReserved = async (segmentId, intervalMin, intervalMax, fxSegmentId, fxIntervalMin, fxIntervalMax) => {
   try {
     const transactionTimestamp = Time.getUTCString(new Date())
     const knex = await Db.getKnex()
@@ -607,66 +946,129 @@ const timeoutExpireReserved = async (segmentId, intervalMin, intervalMax) => {
                 .max('transferStateChangeId AS maxTransferStateChangeId')
                 .where('transferStateChangeId', '>', intervalMin)
                 .andWhere('transferStateChangeId', '<=', intervalMax)
-                .groupBy('transferId').as('ts'), 'ts.transferId', 't.transferId'
+                .groupBy('transferId')
+                .as('ts'), 'ts.transferId', 't.transferId'
               )
               .innerJoin('transferStateChange AS tsc', 'tsc.transferStateChangeId', 'ts.maxTransferStateChangeId')
               .leftJoin('transferTimeout AS tt', 'tt.transferId', 't.transferId')
               .whereNull('tt.transferId')
               .whereIn('tsc.transferStateId', [`${Enum.Transfers.TransferInternalState.RECEIVED_PREPARE}`, `${Enum.Transfers.TransferState.RESERVED}`])
               .select('t.transferId', 't.expirationDate')
-          }) // .toSQL().sql
-        // console.log('SQL: ' + q1)
+          })
 
-        // Insert `transferStateChange` records for RECEIVED_PREPARE
-        await knex.from(knex.raw('transferStateChange (transferId, transferStateId, reason)')).transacting(trx)
+        // Insert `fxTransferTimeout` records for fxTransfers found between the interval intervalMin <= intervalMax and related fxTransfers
+        await knex.from(knex.raw('fxTransferTimeout (commitRequestId, expirationDate)')).transacting(trx)
           .insert(function () {
-            this.from('transferTimeout AS tt')
-              .innerJoin(knex('transferStateChange AS tsc1')
-                .select('tsc1.transferId')
-                .max('tsc1.transferStateChangeId AS maxTransferStateChangeId')
-                .innerJoin('transferTimeout AS tt1', 'tt1.transferId', 'tsc1.transferId')
-                .groupBy('tsc1.transferId').as('ts'), 'ts.transferId', 'tt.transferId'
+            this.from('fxTransfer AS ft')
+              .innerJoin(knex('fxTransferStateChange')
+                .select('commitRequestId')
+                .max('fxTransferStateChangeId AS maxFxTransferStateChangeId')
+                .where('fxTransferStateChangeId', '>', fxIntervalMin)
+                .andWhere('fxTransferStateChangeId', '<=', fxIntervalMax)
+                .groupBy('commitRequestId').as('fts'), 'fts.commitRequestId', 'ft.commitRequestId'
               )
-              .innerJoin('transferStateChange AS tsc', 'tsc.transferStateChangeId', 'ts.maxTransferStateChangeId')
-              .where('tt.expirationDate', '<', transactionTimestamp)
-              .andWhere('tsc.transferStateId', `${Enum.Transfers.TransferInternalState.RECEIVED_PREPARE}`)
-              .select('tt.transferId', knex.raw('?', Enum.Transfers.TransferInternalState.EXPIRED_PREPARED), knex.raw('?', 'Aborted by Timeout Handler'))
-          }) // .toSQL().sql
-        // console.log('SQL: ' + q2)
-
-        // Insert `transferStateChange` records for RESERVED
-        await knex.from(knex.raw('transferStateChange (transferId, transferStateId, reason)')).transacting(trx)
+              .innerJoin('fxTransferStateChange AS ftsc', 'ftsc.fxTransferStateChangeId', 'fts.maxFxTransferStateChangeId')
+              .leftJoin('fxTransferTimeout AS ftt', 'ftt.commitRequestId', 'ft.commitRequestId')
+              .leftJoin('fxTransfer AS ft1', 'ft1.determiningTransferId', 'ft.determiningTransferId')
+              .whereNull('ftt.commitRequestId')
+              .whereIn('ftsc.transferStateId', [
+                `${Enum.Transfers.TransferInternalState.RECEIVED_PREPARE}`,
+                `${Enum.Transfers.TransferState.RESERVED}`,
+                `${Enum.Transfers.TransferInternalState.RECEIVED_FULFIL_DEPENDENT}`
+              ]) // TODO: this needs to be updated to proper states for fx
+              .select('ft1.commitRequestId', 'ft.expirationDate') // Passing expiration date of the timed out fxTransfer for all related fxTransfers
+          })
+
+        await _processTimeoutEntries(knex, trx, transactionTimestamp)
+        await _processFxTimeoutEntries(knex, trx, transactionTimestamp)
+
+        // Insert `fxTransferTimeout` records for the related fxTransfers, or update if exists. The expiration date will be of the transfer and not from fxTransfer
+        await knex.from(knex.raw('fxTransferTimeout (commitRequestId, expirationDate)')).transacting(trx)
           .insert(function () {
-            this.from('transferTimeout AS tt')
-              .innerJoin(knex('transferStateChange AS tsc1')
-                .select('tsc1.transferId')
-                .max('tsc1.transferStateChangeId AS maxTransferStateChangeId')
-                .innerJoin('transferTimeout AS tt1', 'tt1.transferId', 'tsc1.transferId')
-                .groupBy('tsc1.transferId').as('ts'), 'ts.transferId', 'tt.transferId'
+            this.from('fxTransfer AS ft')
+              .innerJoin(
+                knex('transferTimeout AS tt')
+                  .select('tt.transferId', 'tt.expirationDate')
+                  .innerJoin(
+                    knex('transferStateChange as tsc1')
+                      .select('tsc1.transferId')
+                      .max('tsc1.transferStateChangeId AS maxTransferStateChangeId')
+                      .innerJoin('transferTimeout AS tt1', 'tt1.transferId', 'tsc1.transferId')
+                      .groupBy('tsc1.transferId')
+                      .as('ts'),
+                    'ts.transferId', 'tt.transferId'
+                  )
+                  .innerJoin('transferStateChange AS tsc', 'tsc.transferStateChangeId', 'ts.maxTransferStateChangeId')
+                  .where('tt.expirationDate', '<', transactionTimestamp)
+                  .whereIn('tsc.transferStateId', [
+                  `${Enum.Transfers.TransferInternalState.RESERVED_TIMEOUT}`,
+                  `${Enum.Transfers.TransferInternalState.EXPIRED_PREPARED}`
+                  ])
+                  .as('tt1'),
+                'ft.determiningTransferId', 'tt1.transferId'
               )
-              .innerJoin('transferStateChange AS tsc', 'tsc.transferStateChangeId', 'ts.maxTransferStateChangeId')
-              .where('tt.expirationDate', '<', transactionTimestamp)
-              .andWhere('tsc.transferStateId', `${Enum.Transfers.TransferState.RESERVED}`)
-              .select('tt.transferId', knex.raw('?', Enum.Transfers.TransferInternalState.RESERVED_TIMEOUT), knex.raw('?', 'Marked for expiration by Timeout Handler'))
-          }) // .toSQL().sql
-        // console.log('SQL: ' + q3)
-
-        // Insert `transferError` records
-        await knex.from(knex.raw('transferError (transferId, transferStateChangeId, errorCode, errorDescription)')).transacting(trx)
+              .select('ft.commitRequestId', 'tt1.expirationDate')
+          })
+          .onConflict('commitRequestId')
+          .merge({
+            expirationDate: knex.raw('VALUES(expirationDate)')
+          })
+
+        // Insert `transferTimeout` records for the related transfers, or update if exists. The expiration date will be of the fxTransfer and not from transfer
+        await knex.from(knex.raw('transferTimeout (transferId, expirationDate)')).transacting(trx)
           .insert(function () {
-            this.from('transferTimeout AS tt')
-              .innerJoin(knex('transferStateChange AS tsc1')
-                .select('tsc1.transferId')
-                .max('tsc1.transferStateChangeId AS maxTransferStateChangeId')
-                .innerJoin('transferTimeout AS tt1', 'tt1.transferId', 'tsc1.transferId')
-                .groupBy('tsc1.transferId').as('ts'), 'ts.transferId', 'tt.transferId'
+            this.from('fxTransfer AS ft')
+              .innerJoin(
+                knex('fxTransferTimeout AS ftt')
+                  .select('ftt.commitRequestId', 'ftt.expirationDate')
+                  .innerJoin(
+                    knex('fxTransferStateChange AS ftsc1')
+                      .select('ftsc1.commitRequestId')
+                      .max('ftsc1.fxTransferStateChangeId AS maxFxTransferStateChangeId')
+                      .innerJoin('fxTransferTimeout AS ftt1', 'ftt1.commitRequestId', 'ftsc1.commitRequestId')
+                      .groupBy('ftsc1.commitRequestId')
+                      .as('fts'),
+                    'fts.commitRequestId', 'ftt.commitRequestId'
+                  )
+                  .innerJoin('fxTransferStateChange AS ftsc', 'ftsc.fxTransferStateChangeId', 'fts.maxFxTransferStateChangeId')
+                  .where('ftt.expirationDate', '<', transactionTimestamp)
+                  .whereIn('ftsc.transferStateId', [
+                  `${Enum.Transfers.TransferInternalState.RESERVED_TIMEOUT}`,
+                  `${Enum.Transfers.TransferInternalState.EXPIRED_PREPARED}`
+                  ]) // TODO: need to check this for fx
+                  .as('ftt1'),
+                'ft.commitRequestId', 'ftt1.commitRequestId'
               )
-              .innerJoin('transferStateChange AS tsc', 'tsc.transferStateChangeId', 'ts.maxTransferStateChangeId')
-              .where('tt.expirationDate', '<', transactionTimestamp)
-              .andWhere('tsc.transferStateId', `${Enum.Transfers.TransferInternalState.RESERVED_TIMEOUT}`)
-              .select('tt.transferId', 'tsc.transferStateChangeId', knex.raw('?', ErrorHandler.Enums.FSPIOPErrorCodes.TRANSFER_EXPIRED.code), knex.raw('?', ErrorHandler.Enums.FSPIOPErrorCodes.TRANSFER_EXPIRED.message))
-          }) // .toSQL().sql
-        // console.log('SQL: ' + q4)
+              .innerJoin(
+                knex('transferStateChange AS tsc')
+                  .select('tsc.transferId')
+                  .innerJoin(
+                    knex('transferStateChange AS tsc1')
+                      .select('tsc1.transferId')
+                      .max('tsc1.transferStateChangeId AS maxTransferStateChangeId')
+                      .groupBy('tsc1.transferId')
+                      .as('ts'),
+                    'ts.transferId', 'tsc.transferId'
+                  )
+                  .whereRaw('tsc.transferStateChangeId = ts.maxTransferStateChangeId')
+                  .whereIn('tsc.transferStateId', [
+                  `${Enum.Transfers.TransferInternalState.RECEIVED_PREPARE}`,
+                  `${Enum.Transfers.TransferState.RESERVED}`
+                  ])
+                  .as('tt1'),
+                'ft.determiningTransferId', 'tt1.transferId'
+              )
+              .select('tt1.transferId', 'ftt1.expirationDate')
+          })
+          .onConflict('transferId')
+          .merge({
+            expirationDate: knex.raw('VALUES(expirationDate)')
+          })
+
+        await _processTimeoutEntries(knex, trx, transactionTimestamp)
+        await _processFxTimeoutEntries(knex, trx, transactionTimestamp)
+        await _insertTransferErrorEntries(knex, trx, transactionTimestamp)
+        await _insertFxTransferErrorEntries(knex, trx, transactionTimestamp)
 
         if (segmentId === 0) {
           const segment = {
@@ -679,45 +1081,31 @@ const timeoutExpireReserved = async (segmentId, intervalMin, intervalMax) => {
         } else {
           await knex('segment').transacting(trx).where({ segmentId }).update({ value: intervalMax })
         }
-        await trx.commit
+        if (fxSegmentId === 0) {
+          const fxSegment = {
+            segmentType: 'timeout',
+            enumeration: 0,
+            tableName: 'fxTransferStateChange',
+            value: fxIntervalMax
+          }
+          await knex('segment').transacting(trx).insert(fxSegment)
+        } else {
+          await knex('segment').transacting(trx).where({ segmentId: fxSegmentId }).update({ value: fxIntervalMax })
+        }
       } catch (err) {
-        await trx.rollback
         throw ErrorHandler.Factory.reformatFSPIOPError(err)
       }
     }).catch((err) => {
       throw ErrorHandler.Factory.reformatFSPIOPError(err)
     })
 
-    return knex('transferTimeout AS tt')
-      .innerJoin(knex('transferStateChange AS tsc1')
-        .select('tsc1.transferId')
-        .max('tsc1.transferStateChangeId AS maxTransferStateChangeId')
-        .innerJoin('transferTimeout AS tt1', 'tt1.transferId', 'tsc1.transferId')
-        .groupBy('tsc1.transferId').as('ts'), 'ts.transferId', 'tt.transferId'
-      )
-      .innerJoin('transferStateChange AS tsc', 'tsc.transferStateChangeId', 'ts.maxTransferStateChangeId')
-      .innerJoin('transferParticipant AS tp1', function () {
-        this.on('tp1.transferId', 'tt.transferId')
-          .andOn('tp1.transferParticipantRoleTypeId', Enum.Accounts.TransferParticipantRoleType.PAYER_DFSP)
-          .andOn('tp1.ledgerEntryTypeId', Enum.Accounts.LedgerEntryType.PRINCIPLE_VALUE)
-      })
-      .innerJoin('transferParticipant AS tp2', function () {
-        this.on('tp2.transferId', 'tt.transferId')
-          .andOn('tp2.transferParticipantRoleTypeId', Enum.Accounts.TransferParticipantRoleType.PAYEE_DFSP)
-          .andOn('tp2.ledgerEntryTypeId', Enum.Accounts.LedgerEntryType.PRINCIPLE_VALUE)
-      })
-      .innerJoin('participantCurrency AS pc1', 'pc1.participantCurrencyId', 'tp1.participantCurrencyId')
-      .innerJoin('participant AS p1', 'p1.participantId', 'pc1.participantId')
+    const transferTimeoutList = await _getTransferTimeoutList(knex, transactionTimestamp)
+    const fxTransferTimeoutList = await _getFxTransferTimeoutList(knex, transactionTimestamp)
 
-      .innerJoin('participantCurrency AS pc2', 'pc2.participantCurrencyId', 'tp2.participantCurrencyId')
-      .innerJoin('participant AS p2', 'p2.participantId', 'pc2.participantId')
-
-      .leftJoin('bulkTransferAssociation AS bta', 'bta.transferId', 'tt.transferId')
-
-      .where('tt.expirationDate', '<', transactionTimestamp)
-      .select('tt.*', 'tsc.transferStateId', 'tp1.participantCurrencyId AS payerParticipantCurrencyId',
-        'p1.name AS payerFsp', 'p2.name AS payeeFsp', 'tp2.participantCurrencyId AS payeeParticipantCurrencyId',
-        'bta.bulkTransferId')
+    return {
+      transferTimeoutList,
+      fxTransferTimeoutList
+    }
   } catch (err) {
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
@@ -727,119 +1115,113 @@ const transferStateAndPositionUpdate = async function (param1, enums, trx = null
   try {
     const knex = await Db.getKnex()
 
-    const trxFunction = async (trx, doCommit = true) => {
+    const trxFunction = async (trx) => {
       const transactionTimestamp = Time.getUTCString(new Date())
-      let info, transferStateChangeId
-      try {
-        info = await knex('transfer AS t')
-          .join('transferParticipant AS dr', function () {
-            this.on('dr.transferId', 't.transferId')
-              .andOn('dr.amount', '>', 0)
-          })
-          .join('participantCurrency AS drpc', 'drpc.participantCurrencyId', 'dr.participantCurrencyId')
-          .join('participantPosition AS drp', 'drp.participantCurrencyId', 'dr.participantCurrencyId')
-          .join('transferParticipant AS cr', function () {
-            this.on('cr.transferId', 't.transferId')
-              .andOn('cr.amount', '<', 0)
+      const info = await knex('transfer AS t')
+        .join('transferParticipant AS dr', function () {
+          this.on('dr.transferId', 't.transferId')
+            .andOn('dr.amount', '>', 0)
+        })
+        .join('participantCurrency AS drpc', 'drpc.participantCurrencyId', 'dr.participantCurrencyId')
+        .join('participantPosition AS drp', 'drp.participantCurrencyId', 'dr.participantCurrencyId')
+        .join('transferParticipant AS cr', function () {
+          this.on('cr.transferId', 't.transferId')
+            .andOn('cr.amount', '<', 0)
+        })
+        .join('participantCurrency AS crpc', 'crpc.participantCurrencyId', 'dr.participantCurrencyId')
+        .join('participantPosition AS crp', 'crp.participantCurrencyId', 'cr.participantCurrencyId')
+        .join('transferStateChange AS tsc', 'tsc.transferId', 't.transferId')
+        .where('t.transferId', param1.transferId)
+        .whereIn('drpc.ledgerAccountTypeId', [enums.ledgerAccountType.POSITION, enums.ledgerAccountType.SETTLEMENT,
+          enums.ledgerAccountType.HUB_RECONCILIATION, enums.ledgerAccountType.HUB_MULTILATERAL_SETTLEMENT])
+        .whereIn('crpc.ledgerAccountTypeId', [enums.ledgerAccountType.POSITION, enums.ledgerAccountType.SETTLEMENT,
+          enums.ledgerAccountType.HUB_RECONCILIATION, enums.ledgerAccountType.HUB_MULTILATERAL_SETTLEMENT])
+        .select('dr.participantCurrencyId AS drAccountId', 'dr.amount AS drAmount', 'drp.participantPositionId AS drPositionId',
+          'drp.value AS drPositionValue', 'drp.reservedValue AS drReservedValue', 'cr.participantCurrencyId AS crAccountId',
+          'cr.amount AS crAmount', 'crp.participantPositionId AS crPositionId', 'crp.value AS crPositionValue',
+          'crp.reservedValue AS crReservedValue', 'tsc.transferStateId', 'drpc.ledgerAccountTypeId', 'crpc.ledgerAccountTypeId')
+        .orderBy('tsc.transferStateChangeId', 'desc')
+        .first()
+        .transacting(trx)
+
+      if (param1.transferStateId === enums.transferState.COMMITTED ||
+          param1.transferStateId === TransferInternalState.RESERVED_FORWARDED
+      ) {
+        await knex('transferStateChange')
+          .insert({
+            transferId: param1.transferId,
+            transferStateId: enums.transferState.RECEIVED_FULFIL,
+            reason: param1.reason,
+            createdDate: param1.createdDate
           })
-          .join('participantCurrency AS crpc', 'crpc.participantCurrencyId', 'dr.participantCurrencyId')
-          .join('participantPosition AS crp', 'crp.participantCurrencyId', 'cr.participantCurrencyId')
-          .join('transferStateChange AS tsc', 'tsc.transferId', 't.transferId')
-          .where('t.transferId', param1.transferId)
-          .whereIn('drpc.ledgerAccountTypeId', [enums.ledgerAccountType.POSITION, enums.ledgerAccountType.SETTLEMENT,
-            enums.ledgerAccountType.HUB_RECONCILIATION, enums.ledgerAccountType.HUB_MULTILATERAL_SETTLEMENT])
-          .whereIn('crpc.ledgerAccountTypeId', [enums.ledgerAccountType.POSITION, enums.ledgerAccountType.SETTLEMENT,
-            enums.ledgerAccountType.HUB_RECONCILIATION, enums.ledgerAccountType.HUB_MULTILATERAL_SETTLEMENT])
-          .select('dr.participantCurrencyId AS drAccountId', 'dr.amount AS drAmount', 'drp.participantPositionId AS drPositionId',
-            'drp.value AS drPositionValue', 'drp.reservedValue AS drReservedValue', 'cr.participantCurrencyId AS crAccountId',
-            'cr.amount AS crAmount', 'crp.participantPositionId AS crPositionId', 'crp.value AS crPositionValue',
-            'crp.reservedValue AS crReservedValue', 'tsc.transferStateId', 'drpc.ledgerAccountTypeId', 'crpc.ledgerAccountTypeId')
-          .orderBy('tsc.transferStateChangeId', 'desc')
-          .first()
           .transacting(trx)
-
-        if (param1.transferStateId === enums.transferState.COMMITTED) {
-          await knex('transferStateChange')
-            .insert({
-              transferId: param1.transferId,
-              transferStateId: enums.transferState.RECEIVED_FULFIL,
-              reason: param1.reason,
-              createdDate: param1.createdDate
-            })
-            .transacting(trx)
-        } else if (param1.transferStateId === enums.transferState.ABORTED_REJECTED) {
-          await knex('transferStateChange')
-            .insert({
-              transferId: param1.transferId,
-              transferStateId: enums.transferState.RECEIVED_REJECT,
-              reason: param1.reason,
-              createdDate: param1.createdDate
-            })
-            .transacting(trx)
-        }
-        transferStateChangeId = await knex('transferStateChange')
+      } else if (param1.transferStateId === enums.transferState.ABORTED_REJECTED) {
+        await knex('transferStateChange')
           .insert({
             transferId: param1.transferId,
-            transferStateId: param1.transferStateId,
+            transferStateId: enums.transferState.RECEIVED_REJECT,
             reason: param1.reason,
             createdDate: param1.createdDate
           })
           .transacting(trx)
+      }
+      const transferStateChangeId = await knex('transferStateChange')
+        .insert({
+          transferId: param1.transferId,
+          transferStateId: param1.transferStateId,
+          reason: param1.reason,
+          createdDate: param1.createdDate
+        })
+        .transacting(trx)
 
-        if (param1.drUpdated === true) {
-          if (param1.transferStateId === 'ABORTED_REJECTED') {
-            info.drAmount = -info.drAmount
-          }
-          await knex('participantPosition')
-            .update({
-              value: new MLNumber(info.drPositionValue).add(info.drAmount).toFixed(Config.AMOUNT.SCALE),
-              changedDate: transactionTimestamp
-            })
-            .where('participantPositionId', info.drPositionId)
-            .transacting(trx)
-
-          await knex('participantPositionChange')
-            .insert({
-              participantPositionId: info.drPositionId,
-              transferStateChangeId,
-              value: new MLNumber(info.drPositionValue).add(info.drAmount).toFixed(Config.AMOUNT.SCALE),
-              reservedValue: info.drReservedValue,
-              createdDate: param1.createdDate
-            })
-            .transacting(trx)
+      if (param1.drUpdated === true) {
+        if (param1.transferStateId === 'ABORTED_REJECTED') {
+          info.drAmount = -info.drAmount
         }
+        await knex('participantPosition')
+          .update({
+            value: new MLNumber(info.drPositionValue).add(info.drAmount).toFixed(Config.AMOUNT.SCALE),
+            changedDate: transactionTimestamp
+          })
+          .where('participantPositionId', info.drPositionId)
+          .transacting(trx)
 
-        if (param1.crUpdated === true) {
-          if (param1.transferStateId === 'ABORTED_REJECTED') {
-            info.crAmount = -info.crAmount
-          }
-          await knex('participantPosition')
-            .update({
-              value: new MLNumber(info.crPositionValue).add(info.crAmount).toFixed(Config.AMOUNT.SCALE),
-              changedDate: transactionTimestamp
-            })
-            .where('participantPositionId', info.crPositionId)
-            .transacting(trx)
-
-          await knex('participantPositionChange')
-            .insert({
-              participantPositionId: info.crPositionId,
-              transferStateChangeId,
-              value: new MLNumber(info.crPositionValue).add(info.crAmount).toFixed(Config.AMOUNT.SCALE),
-              reservedValue: info.crReservedValue,
-              createdDate: param1.createdDate
-            })
-            .transacting(trx)
-        }
+        await knex('participantPositionChange')
+          .insert({
+            participantPositionId: info.drPositionId,
+            participantCurrencyId: info.drAccountId,
+            transferStateChangeId,
+            value: new MLNumber(info.drPositionValue).add(info.drAmount).toFixed(Config.AMOUNT.SCALE),
+            change: info.drAmount,
+            reservedValue: info.drReservedValue,
+            createdDate: param1.createdDate
+          })
+          .transacting(trx)
+      }
 
-        if (doCommit) {
-          await trx.commit
-        }
-      } catch (err) {
-        if (doCommit) {
-          await trx.rollback
+      if (param1.crUpdated === true) {
+        if (param1.transferStateId === 'ABORTED_REJECTED') {
+          info.crAmount = -info.crAmount
         }
-        throw err
+        await knex('participantPosition')
+          .update({
+            value: new MLNumber(info.crPositionValue).add(info.crAmount).toFixed(Config.AMOUNT.SCALE),
+            changedDate: transactionTimestamp
+          })
+          .where('participantPositionId', info.crPositionId)
+          .transacting(trx)
+
+        await knex('participantPositionChange')
+          .insert({
+            participantPositionId: info.crPositionId,
+            participantCurrencyId: info.crAccountId,
+            transferStateChangeId,
+            value: new MLNumber(info.crPositionValue).add(info.crAmount).toFixed(Config.AMOUNT.SCALE),
+            change: info.crAmount,
+            reservedValue: info.crReservedValue,
+            createdDate: param1.createdDate
+          })
+          .transacting(trx)
       }
       return {
         transferStateChangeId,
@@ -849,7 +1231,7 @@ const transferStateAndPositionUpdate = async function (param1, enums, trx = null
     }
 
     if (trx) {
-      return await trxFunction(trx, false)
+      return await trxFunction(trx)
     } else {
       return await knex.transaction(trxFunction)
     }
@@ -858,115 +1240,128 @@ const transferStateAndPositionUpdate = async function (param1, enums, trx = null
   }
 }
 
-const reconciliationTransferPrepare = async function (payload, transactionTimestamp, enums, trx = null) {
+const updatePrepareReservedForwarded = async function (transferId) {
   try {
     const knex = await Db.getKnex()
+    return await knex('transferStateChange')
+      .insert({
+        transferId,
+        transferStateId: TransferInternalState.RESERVED_FORWARDED,
+        reason: null,
+        createdDate: Time.getUTCString(new Date())
+      })
+  } catch (err) {
+    throw ErrorHandler.Factory.reformatFSPIOPError(err)
+  }
+}
 
-    const trxFunction = async (trx, doCommit = true) => {
-      try {
-        // transferDuplicateCheck check and insert is done prior to calling the prepare
-        // see admin/handler.js :: transfer -> Comparators.duplicateCheckComparator
-
-        // Insert transfer
-        await knex('transfer')
-          .insert({
-            transferId: payload.transferId,
-            amount: payload.amount.amount,
-            currencyId: payload.amount.currency,
-            ilpCondition: 0,
-            expirationDate: Time.getUTCString(new Date(+new Date() +
-              1000 * Number(Config.INTERNAL_TRANSFER_VALIDITY_SECONDS))),
-            createdDate: transactionTimestamp
-          })
-          .transacting(trx)
+const reconciliationTransferPrepare = async function (payload, transactionTimestamp, enums, trx = null) {
+  try {
+    const knex = await Db.getKnex()
 
-        // Retrieve hub reconciliation account for the specified currency
-        const { reconciliationAccountId } = await knex('participantCurrency')
-          .select('participantCurrencyId AS reconciliationAccountId')
-          .where('participantId', Config.HUB_ID)
-          .andWhere('currencyId', payload.amount.currency)
-          .first()
-          .transacting(trx)
+    const trxFunction = async (trx) => {
+      // transferDuplicateCheck check and insert is done prior to calling the prepare
+      // see admin/handler.js :: transfer -> Comparators.duplicateCheckComparator
 
-        let ledgerEntryTypeId, amount
-        if (payload.action === Enum.Transfers.AdminTransferAction.RECORD_FUNDS_IN) {
-          ledgerEntryTypeId = enums.ledgerEntryType.RECORD_FUNDS_IN
-          amount = payload.amount.amount
-        } else if (payload.action === Enum.Transfers.AdminTransferAction.RECORD_FUNDS_OUT_PREPARE_RESERVE) {
-          ledgerEntryTypeId = enums.ledgerEntryType.RECORD_FUNDS_OUT
-          amount = -payload.amount.amount
-        } else {
-          throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.INTERNAL_SERVER_ERROR, 'Action not allowed for reconciliationTransferPrepare')
-        }
+      // Insert transfer
+      await knex('transfer')
+        .insert({
+          transferId: payload.transferId,
+          amount: payload.amount.amount,
+          currencyId: payload.amount.currency,
+          ilpCondition: 0,
+          expirationDate: Time.getUTCString(new Date(+new Date() +
+            1000 * Number(Config.INTERNAL_TRANSFER_VALIDITY_SECONDS))),
+          createdDate: transactionTimestamp
+        })
+        .transacting(trx)
 
-        // Insert transferParticipant records
-        await knex('transferParticipant')
-          .insert({
-            transferId: payload.transferId,
-            participantCurrencyId: reconciliationAccountId,
-            transferParticipantRoleTypeId: enums.transferParticipantRoleType.HUB,
-            ledgerEntryTypeId,
-            amount,
-            createdDate: transactionTimestamp
-          })
-          .transacting(trx)
-        await knex('transferParticipant')
-          .insert({
-            transferId: payload.transferId,
-            participantCurrencyId: payload.participantCurrencyId,
-            transferParticipantRoleTypeId: enums.transferParticipantRoleType.DFSP_SETTLEMENT,
-            ledgerEntryTypeId,
-            amount: -amount,
-            createdDate: transactionTimestamp
-          })
-          .transacting(trx)
+      // Retrieve hub reconciliation account for the specified currency
+      const { reconciliationAccountId } = await knex('participantCurrency')
+        .select('participantCurrencyId AS reconciliationAccountId')
+        .where('participantId', Config.HUB_ID)
+        .andWhere('currencyId', payload.amount.currency)
+        .first()
+        .transacting(trx)
 
-        await knex('transferStateChange')
-          .insert({
-            transferId: payload.transferId,
-            transferStateId: enums.transferState.RECEIVED_PREPARE,
-            reason: payload.reason,
-            createdDate: transactionTimestamp
-          })
-          .transacting(trx)
+      // Get participantId based on participantCurrencyId
+      const { participantId } = await knex('participantCurrency')
+        .select('participantId')
+        .where('participantCurrencyId', payload.participantCurrencyId)
+        .first()
+        .transacting(trx)
+
+      let ledgerEntryTypeId, amount
+      if (payload.action === Enum.Transfers.AdminTransferAction.RECORD_FUNDS_IN) {
+        ledgerEntryTypeId = enums.ledgerEntryType.RECORD_FUNDS_IN
+        amount = payload.amount.amount
+      } else if (payload.action === Enum.Transfers.AdminTransferAction.RECORD_FUNDS_OUT_PREPARE_RESERVE) {
+        ledgerEntryTypeId = enums.ledgerEntryType.RECORD_FUNDS_OUT
+        amount = -payload.amount.amount
+      } else {
+        throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.INTERNAL_SERVER_ERROR, 'Action not allowed for reconciliationTransferPrepare')
+      }
 
-        // Save transaction reference and transfer extensions
-        let transferExtensions = []
-        transferExtensions.push({
+      // Insert transferParticipant records
+      await knex('transferParticipant')
+        .insert({
           transferId: payload.transferId,
-          key: 'externalReference',
-          value: payload.externalReference,
+          participantId: Config.HUB_ID,
+          participantCurrencyId: reconciliationAccountId,
+          transferParticipantRoleTypeId: enums.transferParticipantRoleType.HUB,
+          ledgerEntryTypeId,
+          amount,
           createdDate: transactionTimestamp
         })
-        if (payload.extensionList && payload.extensionList.extension) {
-          transferExtensions = transferExtensions.concat(
-            payload.extensionList.extension.map(ext => {
-              return {
-                transferId: payload.transferId,
-                key: ext.key,
-                value: ext.value,
-                createdDate: transactionTimestamp
-              }
-            })
-          )
-        }
-        for (const transferExtension of transferExtensions) {
-          await knex('transferExtension').insert(transferExtension).transacting(trx)
-        }
+        .transacting(trx)
+      await knex('transferParticipant')
+        .insert({
+          transferId: payload.transferId,
+          participantId,
+          participantCurrencyId: payload.participantCurrencyId,
+          transferParticipantRoleTypeId: enums.transferParticipantRoleType.DFSP_SETTLEMENT,
+          ledgerEntryTypeId,
+          amount: -amount,
+          createdDate: transactionTimestamp
+        })
+        .transacting(trx)
 
-        if (doCommit) {
-          await trx.commit
-        }
-      } catch (err) {
-        if (doCommit) {
-          await trx.rollback
-        }
-        throw err
+      await knex('transferStateChange')
+        .insert({
+          transferId: payload.transferId,
+          transferStateId: enums.transferState.RECEIVED_PREPARE,
+          reason: payload.reason,
+          createdDate: transactionTimestamp
+        })
+        .transacting(trx)
+
+      // Save transaction reference and transfer extensions
+      let transferExtensions = []
+      transferExtensions.push({
+        transferId: payload.transferId,
+        key: 'externalReference',
+        value: payload.externalReference,
+        createdDate: transactionTimestamp
+      })
+      if (payload.extensionList && payload.extensionList.extension) {
+        transferExtensions = transferExtensions.concat(
+          payload.extensionList.extension.map(ext => {
+            return {
+              transferId: payload.transferId,
+              key: ext.key,
+              value: ext.value,
+              createdDate: transactionTimestamp
+            }
+          })
+        )
+      }
+      for (const transferExtension of transferExtensions) {
+        await knex('transferExtension').insert(transferExtension).transacting(trx)
       }
     }
 
     if (trx) {
-      await trxFunction(trx, false)
+      await trxFunction(trx)
     } else {
       await knex.transaction(trxFunction)
     }
@@ -980,38 +1375,27 @@ const reconciliationTransferReserve = async function (payload, transactionTimest
   try {
     const knex = await Db.getKnex()
 
-    const trxFunction = async (trx, doCommit = true) => {
-      try {
-        const param1 = {
-          transferId: payload.transferId,
-          transferStateId: enums.transferState.RESERVED,
-          reason: payload.reason,
-          createdDate: transactionTimestamp,
-          drUpdated: true,
-          crUpdated: false
-        }
-        const positionResult = await TransferFacade.transferStateAndPositionUpdate(param1, enums, trx)
-
-        if (payload.action === Enum.Transfers.AdminTransferAction.RECORD_FUNDS_OUT_PREPARE_RESERVE &&
-          positionResult.drPositionValue > 0) {
-          payload.reason = 'Aborted due to insufficient funds'
-          payload.action = Enum.Transfers.AdminTransferAction.RECORD_FUNDS_OUT_ABORT
-          await TransferFacade.reconciliationTransferAbort(payload, transactionTimestamp, enums, trx)
-        }
+    const trxFunction = async (trx) => {
+      const param1 = {
+        transferId: payload.transferId,
+        transferStateId: enums.transferState.RESERVED,
+        reason: payload.reason,
+        createdDate: transactionTimestamp,
+        drUpdated: true,
+        crUpdated: false
+      }
+      const positionResult = await TransferFacade.transferStateAndPositionUpdate(param1, enums, trx)
 
-        if (doCommit) {
-          await trx.commit
-        }
-      } catch (err) {
-        if (doCommit) {
-          await trx.rollback
-        }
-        throw err
+      if (payload.action === Enum.Transfers.AdminTransferAction.RECORD_FUNDS_OUT_PREPARE_RESERVE &&
+        positionResult.drPositionValue > 0) {
+        payload.reason = 'Aborted due to insufficient funds'
+        payload.action = Enum.Transfers.AdminTransferAction.RECORD_FUNDS_OUT_ABORT
+        await TransferFacade.reconciliationTransferAbort(payload, transactionTimestamp, enums, trx)
       }
     }
 
     if (trx) {
-      await trxFunction(trx, false)
+      await trxFunction(trx)
     } else {
       await knex.transaction(trxFunction)
     }
@@ -1025,55 +1409,44 @@ const reconciliationTransferCommit = async function (payload, transactionTimesta
   try {
     const knex = await Db.getKnex()
 
-    const trxFunction = async (trx, doCommit = true) => {
-      try {
-        // Persist transfer state and participant position change
-        const transferId = payload.transferId
-        await knex('transferFulfilmentDuplicateCheck')
-          .insert({
-            transferId
-          })
-          .transacting(trx)
-
-        await knex('transferFulfilment')
-          .insert({
-            transferId,
-            ilpFulfilment: 0,
-            completedDate: transactionTimestamp,
-            isValid: 1,
-            settlementWindowId: null,
-            createdDate: transactionTimestamp
-          })
-          .transacting(trx)
-
-        if (payload.action === Enum.Transfers.AdminTransferAction.RECORD_FUNDS_IN ||
-          payload.action === Enum.Transfers.AdminTransferAction.RECORD_FUNDS_OUT_COMMIT) {
-          const param1 = {
-            transferId: payload.transferId,
-            transferStateId: enums.transferState.COMMITTED,
-            reason: payload.reason,
-            createdDate: transactionTimestamp,
-            drUpdated: false,
-            crUpdated: true
-          }
-          await TransferFacade.transferStateAndPositionUpdate(param1, enums, trx)
-        } else {
-          throw new Error('Action not allowed for reconciliationTransferCommit')
-        }
+    const trxFunction = async (trx) => {
+      // Persist transfer state and participant position change
+      const transferId = payload.transferId
+      await knex('transferFulfilmentDuplicateCheck')
+        .insert({
+          transferId
+        })
+        .transacting(trx)
+
+      await knex('transferFulfilment')
+        .insert({
+          transferId,
+          ilpFulfilment: 0,
+          completedDate: transactionTimestamp,
+          isValid: 1,
+          settlementWindowId: null,
+          createdDate: transactionTimestamp
+        })
+        .transacting(trx)
 
-        if (doCommit) {
-          await trx.commit
-        }
-      } catch (err) {
-        if (doCommit) {
-          await trx.rollback
+      if (payload.action === Enum.Transfers.AdminTransferAction.RECORD_FUNDS_IN ||
+        payload.action === Enum.Transfers.AdminTransferAction.RECORD_FUNDS_OUT_COMMIT) {
+        const param1 = {
+          transferId: payload.transferId,
+          transferStateId: enums.transferState.COMMITTED,
+          reason: payload.reason,
+          createdDate: transactionTimestamp,
+          drUpdated: false,
+          crUpdated: true
         }
-        throw err
+        await TransferFacade.transferStateAndPositionUpdate(param1, enums, trx)
+      } else {
+        throw new Error('Action not allowed for reconciliationTransferCommit')
       }
     }
 
     if (trx) {
-      await trxFunction(trx, false)
+      await trxFunction(trx)
     } else {
       await knex.transaction(trxFunction)
     }
@@ -1087,54 +1460,43 @@ const reconciliationTransferAbort = async function (payload, transactionTimestam
   try {
     const knex = await Db.getKnex()
 
-    const trxFunction = async (trx, doCommit = true) => {
-      try {
-        // Persist transfer state and participant position change
-        const transferId = payload.transferId
-        await knex('transferFulfilmentDuplicateCheck')
-          .insert({
-            transferId
-          })
-          .transacting(trx)
-
-        await knex('transferFulfilment')
-          .insert({
-            transferId,
-            ilpFulfilment: 0,
-            completedDate: transactionTimestamp,
-            isValid: 1,
-            settlementWindowId: null,
-            createdDate: transactionTimestamp
-          })
-          .transacting(trx)
-
-        if (payload.action === Enum.Transfers.AdminTransferAction.RECORD_FUNDS_OUT_ABORT) {
-          const param1 = {
-            transferId: payload.transferId,
-            transferStateId: enums.transferState.ABORTED_REJECTED,
-            reason: payload.reason,
-            createdDate: transactionTimestamp,
-            drUpdated: true,
-            crUpdated: false
-          }
-          await TransferFacade.transferStateAndPositionUpdate(param1, enums, trx)
-        } else {
-          throw new Error('Action not allowed for reconciliationTransferAbort')
-        }
+    const trxFunction = async (trx) => {
+      // Persist transfer state and participant position change
+      const transferId = payload.transferId
+      await knex('transferFulfilmentDuplicateCheck')
+        .insert({
+          transferId
+        })
+        .transacting(trx)
+
+      await knex('transferFulfilment')
+        .insert({
+          transferId,
+          ilpFulfilment: 0,
+          completedDate: transactionTimestamp,
+          isValid: 1,
+          settlementWindowId: null,
+          createdDate: transactionTimestamp
+        })
+        .transacting(trx)
 
-        if (doCommit) {
-          await trx.commit
-        }
-      } catch (err) {
-        if (doCommit) {
-          await trx.rollback
+      if (payload.action === Enum.Transfers.AdminTransferAction.RECORD_FUNDS_OUT_ABORT) {
+        const param1 = {
+          transferId: payload.transferId,
+          transferStateId: enums.transferState.ABORTED_REJECTED,
+          reason: payload.reason,
+          createdDate: transactionTimestamp,
+          drUpdated: true,
+          crUpdated: false
         }
-        throw err
+        await TransferFacade.transferStateAndPositionUpdate(param1, enums, trx)
+      } else {
+        throw new Error('Action not allowed for reconciliationTransferAbort')
       }
     }
 
     if (trx) {
-      await trxFunction(trx, false)
+      await trxFunction(trx)
     } else {
       await knex.transaction(trxFunction)
     }
@@ -1151,11 +1513,9 @@ const getTransferParticipant = async (participantName, transferId) => {
         .where({
           'participant.name': participantName,
           'tp.transferId': transferId,
-          'participant.isActive': 1,
-          'pc.isActive': 1
+          'participant.isActive': 1
         })
-        .innerJoin('participantCurrency AS pc', 'pc.participantId', 'participant.participantId')
-        .innerJoin('transferParticipant AS tp', 'tp.participantCurrencyId', 'pc.participantCurrencyId')
+        .innerJoin('transferParticipant AS tp', 'tp.participantId', 'participant.participantId')
         .select(
           'tp.*'
         )
@@ -1173,10 +1533,8 @@ const recordFundsIn = async (payload, transactionTimestamp, enums) => {
       await TransferFacade.reconciliationTransferPrepare(payload, transactionTimestamp, enums, trx)
       await TransferFacade.reconciliationTransferReserve(payload, transactionTimestamp, enums, trx)
       await TransferFacade.reconciliationTransferCommit(payload, transactionTimestamp, enums, trx)
-      await trx.commit
     } catch (err) {
-      Logger.isErrorEnabled && Logger.error(err)
-      await trx.rollback
+      logger.error('error in recordFundsIn:', err)
       throw ErrorHandler.Factory.reformatFSPIOPError(err)
     }
   })
@@ -1197,7 +1555,8 @@ const TransferFacade = {
   reconciliationTransferCommit,
   reconciliationTransferAbort,
   getTransferParticipant,
-  recordFundsIn
+  recordFundsIn,
+  updatePrepareReservedForwarded
 }
 
 module.exports = TransferFacade