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

package/src/handlers/transfers/handler.js

@@ -40,214 +40,86 @@
 
 const Logger = require('@mojaloop/central-services-logger')
 const EventSdk = require('@mojaloop/event-sdk')
+const ErrorHandler = require('@mojaloop/central-services-error-handling')
+const Metrics = require('@mojaloop/central-services-metrics')
+const { Enum, Util } = require('@mojaloop/central-services-shared')
+const { Consumer, Producer } = require('@mojaloop/central-services-stream').Util
+
+const { logger } = require('../../shared/logger')
+const { ERROR_MESSAGES } = require('../../shared/constants')
+const Config = require('../../lib/config')
 const TransferService = require('../../domain/transfer')
-const Util = require('@mojaloop/central-services-shared').Util
-const Kafka = require('@mojaloop/central-services-shared').Util.Kafka
-const Producer = require('@mojaloop/central-services-stream').Util.Producer
-const Consumer = require('@mojaloop/central-services-stream').Util.Consumer
+const FxService = require('../../domain/fx')
+// TODO: Can define domain functions instead of accessing model directly from handler
+const FxTransferModel = require('../../models/fxTransfer')
+const TransferObjectTransform = require('../../domain/transfer/transform')
+const Participant = require('../../domain/participant')
 const Validator = require('./validator')
-const Enum = require('@mojaloop/central-services-shared').Enum
+const FxFulfilService = require('./FxFulfilService')
+
+// particular handlers
+const { prepare } = require('./prepare')
+
+const { Kafka, Comparators } = Util
 const TransferState = Enum.Transfers.TransferState
 const TransferEventType = Enum.Events.Event.Type
 const TransferEventAction = Enum.Events.Event.Action
-const TransferObjectTransform = require('../../domain/transfer/transform')
-const Metrics = require('@mojaloop/central-services-metrics')
-const Config = require('../../lib/config')
 const decodePayload = Util.StreamingProtocol.decodePayload
-const Comparators = require('@mojaloop/central-services-shared').Util.Comparators
-const ErrorHandler = require('@mojaloop/central-services-error-handling')
-const Participant = require('../../domain/participant')
 
 const consumerCommit = true
 const fromSwitch = true
 
-/**
- * @function TransferPrepareHandler
- *
- * @async
- * @description This is the consumer callback function that gets registered to a topic. This then gets a list of messages,
- * we will only ever use the first message in non batch processing. We then break down the message into its payload and
- * begin validating the payload. Once the payload is validated successfully it will be written to the database to
- * the relevant tables. If the validation fails it is still written to the database for auditing purposes but with an
- * INVALID status. For any duplicate requests we will send appropriate callback based on the transfer state and the hash validation
- *
- * Validator.validatePrepare called to validate the payload of the message
- * TransferService.getById called to get the details of the existing transfer
- * TransferObjectTransform.toTransfer called to transform the transfer object
- * TransferService.prepare called and creates new entries in transfer tables for successful prepare transfer
- * TransferService.logTransferError called to log the invalid request
- *
- * @param {error} error - error thrown if something fails within Kafka
- * @param {array} messages - a list of messages to consume for the relevant topic
- *
- * @returns {object} - Returns a boolean: true if successful, or throws and error if failed
- */
-const prepare = async (error, messages) => {
-  const location = { module: 'PrepareHandler', method: '', path: '' }
-  const histTimerEnd = Metrics.getHistogram(
-    'transfer_prepare',
-    'Consume a prepare transfer message from the kafka topic and process it accordingly',
-    ['success', 'fspId']
-  ).startTimer()
+const fulfil = async (error, messages) => {
   if (error) {
-    histTimerEnd({ success: false, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
     throw ErrorHandler.Factory.reformatFSPIOPError(error)
   }
-  let message = {}
+  let message
   if (Array.isArray(messages)) {
     message = messages[0]
   } else {
     message = messages
   }
-  const parentSpanService = 'cl_transfer_prepare'
   const contextFromMessage = EventSdk.Tracer.extractContextFromMessage(message.value)
-  const span = EventSdk.Tracer.createChildSpanFromContext(parentSpanService, contextFromMessage)
+  const span = EventSdk.Tracer.createChildSpanFromContext('cl_transfer_fulfil', contextFromMessage)
   try {
-    const payload = decodePayload(message.value.content.payload)
-    const headers = message.value.content.headers
-    const action = message.value.metadata.event.action
-    const transferId = payload.transferId
-    span.setTags({ transactionId: transferId })
     await span.audit(message, EventSdk.AuditEventAction.start)
-    const kafkaTopic = message.topic
-    Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, { method: 'prepare' }))
-
-    const actionLetter = action === TransferEventAction.PREPARE
-      ? Enum.Events.ActionLetter.prepare
-      : (action === TransferEventAction.BULK_PREPARE
-          ? Enum.Events.ActionLetter.bulkPrepare
-          : Enum.Events.ActionLetter.unknown)
-
-    let functionality = action === TransferEventAction.PREPARE
-      ? TransferEventType.NOTIFICATION
-      : (action === TransferEventAction.BULK_PREPARE
-          ? TransferEventType.BULK_PROCESSING
-          : Enum.Events.ActionLetter.unknown)
-    const params = { message, kafkaTopic, decodedPayload: payload, span, consumer: Consumer, producer: Producer }
-
-    Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, { path: 'dupCheck' }))
-    const histTimerDuplicateCheckEnd = Metrics.getHistogram(
-      'handler_transfers',
-      'prepare_duplicateCheckComparator - Metrics for transfer handler',
-      ['success', 'funcName']
-    ).startTimer()
-
-    const { hasDuplicateId, hasDuplicateHash } = await Comparators.duplicateCheckComparator(transferId, payload, TransferService.getTransferDuplicateCheck, TransferService.saveTransferDuplicateCheck)
-    histTimerDuplicateCheckEnd({ success: true, funcName: 'prepare_duplicateCheckComparator' })
-    if (hasDuplicateId && hasDuplicateHash) {
-      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, 'handleResend'))
-      const transfer = await TransferService.getByIdLight(transferId)
-      const transferStateEnum = transfer && transfer.transferStateEnumeration
-      const eventDetail = { functionality, action: TransferEventAction.PREPARE_DUPLICATE }
-      if ([TransferState.COMMITTED, TransferState.ABORTED].includes(transferStateEnum)) {
-        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, 'finalized'))
-        if (action === TransferEventAction.PREPARE) {
-          Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callback--${actionLetter}1`))
-          message.value.content.payload = TransferObjectTransform.toFulfil(transfer)
-          message.value.content.uriParams = { id: transferId }
-          await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail, fromSwitch })
-          histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
-          return true
-        } else if (action === TransferEventAction.BULK_PREPARE) {
-          Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `validationError1--${actionLetter}2`))
-          const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.MODIFIED_REQUEST, 'Individual transfer prepare duplicate')
-          await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch })
-          throw fspiopError
-        }
-      } else {
-        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, 'inProgress'))
-        if (action === TransferEventAction.BULK_PREPARE) {
-          Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `validationError2--${actionLetter}4`))
-          const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.MODIFIED_REQUEST, 'Individual transfer prepare duplicate')
-          await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch })
-          throw fspiopError
-        } else { // action === TransferEventAction.PREPARE
-          Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `ignore--${actionLetter}3`))
-          await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit })
-          histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
-          return true
-        }
-      }
-    } else if (hasDuplicateId && !hasDuplicateHash) {
-      Logger.isErrorEnabled && Logger.error(Util.breadcrumb(location, `callbackErrorModified1--${actionLetter}5`))
-      const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.MODIFIED_REQUEST)
-      const eventDetail = { functionality, action }
-      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch })
-      throw fspiopError
-    } else { // !hasDuplicateId
-      const { validationPassed, reasons } = await Validator.validatePrepare(payload, headers)
-      if (validationPassed) {
-        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, { path: 'validationPassed' }))
-        try {
-          Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, 'saveTransfer'))
-          await TransferService.prepare(payload)
-        } catch (err) {
-          Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorInternal1--${actionLetter}6`))
-          Logger.isErrorEnabled && Logger.error(`${Util.breadcrumb(location)}::${err.message}`)
-          const fspiopError = ErrorHandler.Factory.reformatFSPIOPError(err, ErrorHandler.Enums.FSPIOPErrorCodes.INTERNAL_SERVER_ERROR)
-          const eventDetail = { functionality, action: TransferEventAction.PREPARE }
-          /**
-           * TODO: BULK-Handle at BulkProcessingHandler (not in scope of #967)
-           * HOWTO: Stop execution at the `TransferService.prepare`, stop mysql,
-           * continue execution to catch block, start mysql
-           */
-          Logger.isErrorEnabled && Logger.error(`${Util.breadcrumb(location)}::${err.message}`)
-          await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch })
-          throw fspiopError
-        }
-        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `positionTopic1--${actionLetter}7`))
-        functionality = TransferEventType.POSITION
-        const eventDetail = { functionality, action }
-        // Key position prepare message with payer account id
-        const payerAccount = await Participant.getAccountByNameAndCurrency(payload.payerFsp, payload.amount.currency, Enum.Accounts.LedgerAccountType.POSITION)
-        // We route bulk-prepare and prepare messages differently based on the topic configured for it.
-        // Note: The batch handler does not currently support bulk-prepare messages, only prepare messages are supported.
-        // Therefore, it is necessary to check the action to determine the topic to route to.
-        const topicNameOverride =
-          action === TransferEventAction.BULK_PREPARE
-            ? Config.KAFKA_CONFIG.EVENT_TYPE_ACTION_TOPIC_MAP?.POSITION?.BULK_PREPARE
-            : Config.KAFKA_CONFIG.EVENT_TYPE_ACTION_TOPIC_MAP?.POSITION?.PREPARE
-        await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail, messageKey: payerAccount.participantCurrencyId.toString(), topicNameOverride })
-        histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
-        return true
-      } else {
-        Logger.isErrorEnabled && Logger.error(Util.breadcrumb(location, { path: 'validationFailed' }))
-        try {
-          Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, 'saveInvalidRequest'))
-          await TransferService.prepare(payload, reasons.toString(), false)
-        } catch (err) {
-          Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorInternal2--${actionLetter}8`))
-          Logger.isErrorEnabled && Logger.error(`${Util.breadcrumb(location)}::${err.message}`)
-          const fspiopError = ErrorHandler.Factory.reformatFSPIOPError(err, ErrorHandler.Enums.FSPIOPErrorCodes.INTERNAL_SERVER_ERROR)
-          const eventDetail = { functionality, action: TransferEventAction.PREPARE }
-          /**
-           * TODO: BULK-Handle at BulkProcessingHandler (not in scope of #967)
-           * HOWTO: For regular transfers this branch may be triggered by sending
-           * a transfer in a currency not supported by either dfsp and also stopping
-           * mysql at `TransferService.prepare` and starting it after entring catch.
-           * Not sure if it will work for bulk, because of the BulkPrepareHandler.
-           */
-          await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch })
-          throw fspiopError
-        }
-        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorGeneric--${actionLetter}9`))
-        const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.VALIDATION_ERROR, reasons.toString())
-        await TransferService.logTransferError(transferId, ErrorHandler.Enums.FSPIOPErrorCodes.VALIDATION_ERROR.code, reasons.toString())
-        const eventDetail = { functionality, action }
-        /**
-         * TODO: BULK-Handle at BulkProcessingHandler (not in scope of #967)
-         * HOWTO: For regular transfers this branch may be triggered by sending
-         * a tansfer in a currency not supported by either dfsp. Not sure if it
-         * will be triggered for bulk, because of the BulkPrepareHandler.
-         */
-        await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch })
-        throw fspiopError
+    const action = message.value.metadata.event.action
+
+    const functionality = (() => {
+      switch (action) {
+        case TransferEventAction.COMMIT:
+        case TransferEventAction.FX_COMMIT:
+        case TransferEventAction.RESERVE:
+        case TransferEventAction.FX_RESERVE:
+        case TransferEventAction.REJECT:
+        case TransferEventAction.FX_REJECT:
+        case TransferEventAction.ABORT:
+        case TransferEventAction.FX_ABORT:
+          return TransferEventType.NOTIFICATION
+        case TransferEventAction.BULK_COMMIT:
+        case TransferEventAction.BULK_ABORT:
+          return TransferEventType.BULK_PROCESSING
+        default: return Enum.Events.ActionLetter.unknown
       }
+    })()
+    logger.info('FulfilHandler start:', { action, functionality })
+
+    const fxActions = [
+      TransferEventAction.FX_COMMIT,
+      TransferEventAction.FX_RESERVE,
+      TransferEventAction.FX_REJECT,
+      TransferEventAction.FX_ABORT,
+      TransferEventAction.FX_FORWARDED
+    ]
+
+    if (fxActions.includes(action)) {
+      return await processFxFulfilMessage(message, functionality, span)
+    } else {
+      return await processFulfilMessage(message, functionality, span)
     }
   } catch (err) {
-    histTimerEnd({ success: false, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
+    logger.error(`error in FulfilHandler: ${err?.message}`, { err })
     const fspiopError = ErrorHandler.Factory.reformatFSPIOPError(err)
-    Logger.isErrorEnabled && Logger.error(`${Util.breadcrumb(location)}::${err.message}--P0`)
     const state = new EventSdk.EventStateMetadata(EventSdk.EventStatusType.failed, fspiopError.apiErrorCode.code, fspiopError.apiErrorCode.message)
     await span.error(fspiopError, state)
     await span.finish(fspiopError.message, state)
@@ -259,107 +131,82 @@ const prepare = async (error, messages) => {
   }
 }
 
-const fulfil = async (error, messages) => {
+const processFulfilMessage = async (message, functionality, span) => {
   const location = { module: 'FulfilHandler', method: '', path: '' }
   const histTimerEnd = Metrics.getHistogram(
     'transfer_fulfil',
     'Consume a fulfil transfer message from the kafka topic and process it accordingly',
     ['success', 'fspId']
   ).startTimer()
-  if (error) {
-    throw ErrorHandler.Factory.reformatFSPIOPError(error)
-  }
-  let message = {}
-  if (Array.isArray(messages)) {
-    message = messages[0]
-  } else {
-    message = messages
-  }
-  const contextFromMessage = EventSdk.Tracer.extractContextFromMessage(message.value)
-  const span = EventSdk.Tracer.createChildSpanFromContext('cl_transfer_fulfil', contextFromMessage)
-  try {
-    await span.audit(message, EventSdk.AuditEventAction.start)
-    const payload = decodePayload(message.value.content.payload)
-    const headers = message.value.content.headers
-    const type = message.value.metadata.event.type
-    const action = message.value.metadata.event.action
-    const transferId = message.value.content.uriParams.id
-    const kafkaTopic = message.topic
-    Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, { method: `fulfil:${action}` }))
 
-    const actionLetter = (() => {
-      switch (action) {
-        case TransferEventAction.COMMIT: return Enum.Events.ActionLetter.commit
-        case TransferEventAction.RESERVE: return Enum.Events.ActionLetter.reserve
-        case TransferEventAction.REJECT: return Enum.Events.ActionLetter.reject
-        case TransferEventAction.ABORT: return Enum.Events.ActionLetter.abort
-        case TransferEventAction.BULK_COMMIT: return Enum.Events.ActionLetter.bulkCommit
-        case TransferEventAction.BULK_ABORT: return Enum.Events.ActionLetter.bulkAbort
-        default: return Enum.Events.ActionLetter.unknown
-      }
-    })()
+  const payload = decodePayload(message.value.content.payload)
+  const headers = message.value.content.headers
+  const type = message.value.metadata.event.type
+  const action = message.value.metadata.event.action
+  const transferId = message.value.content.uriParams.id
+  const kafkaTopic = message.topic
+  Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, { method: `fulfil:${action}` }))
 
-    const functionality = (() => {
-      switch (action) {
-        case TransferEventAction.COMMIT:
-        case TransferEventAction.RESERVE:
-        case TransferEventAction.REJECT:
-        case TransferEventAction.ABORT:
-          return TransferEventType.NOTIFICATION
-        case TransferEventAction.BULK_COMMIT:
-        case TransferEventAction.BULK_ABORT:
-          return TransferEventType.BULK_PROCESSING
-        default: return Enum.Events.ActionLetter.unknown
-      }
-    })()
-
-    // fulfil-specific declarations
-    const isTransferError = action === TransferEventAction.ABORT
-    const params = { message, kafkaTopic, decodedPayload: payload, span, consumer: Consumer, producer: Producer }
-
-    Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, { path: 'getById' }))
-
-    // We fail early and silently to allow timeout handler abort transfer
-    // if 'RESERVED' transfer state is sent in with v1.0 content-type
-    if (headers['content-type'].split('=')[1] === '1.0' && payload.transferState === TransferState.RESERVED) {
-      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `failSilentlyforReservedStateWith1.0ContentType--${actionLetter}0`))
-      const errorMessage = 'action "RESERVE" is not allowed in fulfil handler for v1.0 clients.'
-      Logger.isErrorEnabled && Logger.error(errorMessage)
-      !!span && span.error(errorMessage)
-      histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
-      return true
+  const actionLetter = (() => {
+    switch (action) {
+      case TransferEventAction.COMMIT: return Enum.Events.ActionLetter.commit
+      case TransferEventAction.RESERVE: return Enum.Events.ActionLetter.reserve
+      case TransferEventAction.REJECT: return Enum.Events.ActionLetter.reject
+      case TransferEventAction.ABORT: return Enum.Events.ActionLetter.abort
+      case TransferEventAction.BULK_COMMIT: return Enum.Events.ActionLetter.bulkCommit
+      case TransferEventAction.BULK_ABORT: return Enum.Events.ActionLetter.bulkAbort
+      default: return Enum.Events.ActionLetter.unknown
     }
+  })()
+
+  // We fail early and silently to allow timeout handler abort transfer
+  // if 'RESERVED' transfer state is sent in with v1.0 content-type
+  if (headers['content-type'].split('=')[1] === '1.0' && payload.transferState === TransferState.RESERVED) {
+    Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `failSilentlyforReservedStateWith1.0ContentType--${actionLetter}0`))
+    const errorMessage = 'action "RESERVE" is not allowed in fulfil handler for v1.0 clients.'
+    Logger.isErrorEnabled && Logger.error(errorMessage)
+    !!span && span.error(errorMessage)
+    return true
+  }
 
-    const transfer = await TransferService.getById(transferId)
-    const transferStateEnum = transfer && transfer.transferStateEnumeration
-
-    // List of valid actions that Source & Destination headers should be checked
-    const validActionsForRouteValidations = [
-      TransferEventAction.COMMIT,
-      TransferEventAction.RESERVE,
-      TransferEventAction.REJECT,
-      TransferEventAction.ABORT
-    ]
-
-    if (!transfer) {
-      Logger.isErrorEnabled && Logger.error(Util.breadcrumb(location, `callbackInternalServerErrorNotFound--${actionLetter}1`))
-      const fspiopError = ErrorHandler.Factory.createInternalServerFSPIOPError('transfer not found')
-      const eventDetail = { functionality, action: TransferEventAction.COMMIT }
-      /**
-       * TODO: BULK-Handle at BulkProcessingHandler (not in scope of #967)
-       * HOWTO: The list of individual transfers being committed should contain
-       * non-existing transferId
-       */
-      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch })
-      throw fspiopError
-
-      // Lets validate FSPIOP Source & Destination Headers
-    } else if (
-      validActionsForRouteValidations.includes(action) && // Lets only check headers for specific actions that need checking (i.e. bulk should not since its already done elsewhere)
-      (
-        (headers[Enum.Http.Headers.FSPIOP.SOURCE] && (headers[Enum.Http.Headers.FSPIOP.SOURCE].toLowerCase() !== transfer.payeeFsp.toLowerCase())) ||
-        (headers[Enum.Http.Headers.FSPIOP.DESTINATION] && (headers[Enum.Http.Headers.FSPIOP.DESTINATION].toLowerCase() !== transfer.payerFsp.toLowerCase()))
-      )
+  // fulfil-specific declarations
+  const isTransferError = action === TransferEventAction.ABORT
+  const params = { message, kafkaTopic, decodedPayload: payload, span, consumer: Consumer, producer: Producer }
+
+  Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, { path: 'getById' }))
+
+  const transfer = await TransferService.getById(transferId)
+  const transferStateEnum = transfer && transfer.transferStateEnumeration
+
+  // List of valid actions that Source & Destination headers should be checked
+  const validActionsForRouteValidations = [
+    TransferEventAction.COMMIT,
+    TransferEventAction.RESERVE,
+    TransferEventAction.REJECT,
+    TransferEventAction.ABORT
+  ]
+
+  if (!transfer) {
+    Logger.isErrorEnabled && Logger.error(Util.breadcrumb(location, `callbackInternalServerErrorNotFound--${actionLetter}1`))
+    const fspiopError = ErrorHandler.Factory.createInternalServerFSPIOPError('transfer not found')
+    const eventDetail = { functionality, action: TransferEventAction.COMMIT }
+    /**
+     * TODO: BULK-Handle at BulkProcessingHandler (not in scope of #967)
+     * HOWTO: The list of individual transfers being committed should contain
+     * non-existing transferId
+     */
+    await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch, hubName: Config.HUB_NAME })
+    throw fspiopError
+
+    // Lets validate FSPIOP Source & Destination Headers
+    // In interscheme scenario, we store proxy fsp id in transferParticipant table and hence we can't compare that data with fspiop headers in fulfil
+  } else if (
+    validActionsForRouteValidations.includes(action) // Lets only check headers for specific actions that need checking (i.e. bulk should not since its already done elsewhere)
+  ) {
+    // Check if the payerFsp and payeeFsp are proxies and if they are, skip validating headers
+    if (
+      (headers[Enum.Http.Headers.FSPIOP.SOURCE] && !transfer.payeeIsProxy && (headers[Enum.Http.Headers.FSPIOP.SOURCE].toLowerCase() !== transfer.payeeFsp.toLowerCase())) ||
+      (headers[Enum.Http.Headers.FSPIOP.DESTINATION] && !transfer.payerIsProxy && (headers[Enum.Http.Headers.FSPIOP.DESTINATION].toLowerCase() !== transfer.payerFsp.toLowerCase()))
     ) {
       /**
        * If fulfilment request is coming from a source not matching transfer payee fsp or destination not matching transfer payer fsp,
@@ -370,19 +217,22 @@ const fulfil = async (error, messages) => {
       let fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.VALIDATION_ERROR, 'FSP does not match one of the fsp-id\'s associated with a transfer on the Fulfil callback response')
 
       // Lets make the error specific if the PayeeFSP IDs do not match
-      if (headers[Enum.Http.Headers.FSPIOP.SOURCE].toLowerCase() !== transfer.payeeFsp.toLowerCase()) {
+      if (!transfer.payeeIsProxy && (headers[Enum.Http.Headers.FSPIOP.SOURCE].toLowerCase() !== transfer.payeeFsp.toLowerCase())) {
         fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.VALIDATION_ERROR, `${Enum.Http.Headers.FSPIOP.SOURCE} does not match payee fsp on the Fulfil callback response`)
       }
 
       // Lets make the error specific if the PayerFSP IDs do not match
-      if (headers[Enum.Http.Headers.FSPIOP.DESTINATION].toLowerCase() !== transfer.payerFsp.toLowerCase()) {
+      if (!transfer.payerIsProxy && (headers[Enum.Http.Headers.FSPIOP.DESTINATION].toLowerCase() !== transfer.payerFsp.toLowerCase())) {
         fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.VALIDATION_ERROR, `${Enum.Http.Headers.FSPIOP.DESTINATION} does not match payer fsp on the Fulfil callback response`)
       }
 
       const apiFSPIOPError = fspiopError.toApiErrorObject(Config.ERROR_HANDLING)
 
       // Set the event details to map to an ABORT_VALIDATION event targeted to the Position Handler
-      const eventDetail = { functionality: TransferEventType.POSITION, action: TransferEventAction.ABORT_VALIDATION }
+      const eventDetail = {
+        functionality: TransferEventType.POSITION,
+        action: TransferEventAction.ABORT_VALIDATION
+      }
 
       // Lets handle the abort validation and change the transfer state to reflect this
       const transferAbortResult = await TransferService.handlePayeeResponse(transferId, payload, TransferEventAction.ABORT_VALIDATION, apiFSPIOPError)
@@ -397,7 +247,7 @@ const fulfil = async (error, messages) => {
       // Publish message to Position Handler
       // Key position abort with payer account id
       const payerAccount = await Participant.getAccountByNameAndCurrency(transfer.payerFsp, transfer.currency, Enum.Accounts.LedgerAccountType.POSITION)
-      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: apiFSPIOPError, eventDetail, fromSwitch, toDestination: transfer.payerFsp, messageKey: payerAccount.participantCurrencyId.toString() })
+      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: apiFSPIOPError, eventDetail, fromSwitch, toDestination: transfer.payerFsp, messageKey: payerAccount.participantCurrencyId.toString(), hubName: Config.HUB_NAME })
 
       /**
        * Send patch notification callback to original payee fsp if they asked for a a patch response.
@@ -427,319 +277,486 @@ const fulfil = async (error, messages) => {
           }
         }
         message.value.content.payload = reservedAbortedPayload
-        await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail: reserveAbortedEventDetail, fromSwitch: true, toDestination: transfer.payeeFsp })
+        await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail: reserveAbortedEventDetail, fromSwitch: true, toDestination: transfer.payeeFsp, hubName: Config.HUB_NAME })
       }
 
       throw apiFSPIOPError
     }
-    // If execution continues after this point we are sure transfer exists and source matches payee fsp
-
-    Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, { path: 'dupCheck' }))
-    const histTimerDuplicateCheckEnd = Metrics.getHistogram(
-      'handler_transfers',
-      'fulfil_duplicateCheckComparator - Metrics for transfer handler',
-      ['success', 'funcName']
-    ).startTimer()
-
-    let dupCheckResult
-    if (!isTransferError) {
-      dupCheckResult = await Comparators.duplicateCheckComparator(transferId, payload, TransferService.getTransferFulfilmentDuplicateCheck, TransferService.saveTransferFulfilmentDuplicateCheck)
-    } else {
-      dupCheckResult = await Comparators.duplicateCheckComparator(transferId, payload, TransferService.getTransferErrorDuplicateCheck, TransferService.saveTransferErrorDuplicateCheck)
-    }
-    const { hasDuplicateId, hasDuplicateHash } = dupCheckResult
-    histTimerDuplicateCheckEnd({ success: true, funcName: 'fulfil_duplicateCheckComparator' })
-    if (hasDuplicateId && hasDuplicateHash) {
-      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, 'handleResend'))
-
-      // This is a duplicate message for a transfer that is already in a finalized state
-      // respond as if we received a GET /transfers/{ID} from the client
-      if (transferStateEnum === TransferState.COMMITTED || transferStateEnum === TransferState.ABORTED) {
-        message.value.content.payload = TransferObjectTransform.toFulfil(transfer)
-        const eventDetail = { functionality, action }
-        if (action !== TransferEventAction.RESERVE) {
-          if (!isTransferError) {
-            Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackFinalized2--${actionLetter}3`))
-            eventDetail.action = TransferEventAction.FULFIL_DUPLICATE
-            /**
-             * HOWTO: During bulk fulfil use an individualTransfer from a previous bulk fulfil
-             */
-          } else {
-            Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackFinalized3--${actionLetter}4`))
-            eventDetail.action = TransferEventAction.ABORT_DUPLICATE
-          }
-        }
-        await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail, fromSwitch })
-        histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
-        return true
-      }
+  }
+  // If execution continues after this point we are sure transfer exists and source matches payee fsp
 
-      if (transferStateEnum === TransferState.RECEIVED || transferStateEnum === TransferState.RESERVED) {
-        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `inProgress2--${actionLetter}5`))
-        /**
-         * HOWTO: Nearly impossible to trigger for bulk - an individual transfer from a bulk needs to be triggered
-         * for processing in order to have the fulfil duplicate hash recorded. While it is still in RESERVED state
-         * the individual transfer needs to be requested by another bulk fulfil request!
-         *
-         * TODO: find a way to trigger this code branch and handle it at BulkProcessingHandler (not in scope of #967)
-         */
-        await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, histTimerEnd })
-        histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
-        return true
-      }
+  Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, { path: 'dupCheck' }))
+  const histTimerDuplicateCheckEnd = Metrics.getHistogram(
+    'handler_transfers',
+    'fulfil_duplicateCheckComparator - Metrics for transfer handler',
+    ['success', 'funcName']
+  ).startTimer()
 
-      // Error scenario - transfer.transferStateEnumeration is in some invalid state
-      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorInvalidTransferStateEnum--${actionLetter}6`))
-      const fspiopError = ErrorHandler.Factory.createInternalServerFSPIOPError(
-        `Invalid transferStateEnumeration:(${transferStateEnum}) for event action:(${action}) and type:(${type})`).toApiErrorObject(Config.ERROR_HANDLING)
-      const eventDetail = { functionality, action: TransferEventAction.COMMIT }
-      /**
-       * HOWTO: Impossible to trigger for individual transfer in a bulk? (not in scope of #967)
-       */
-      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError, eventDetail, fromSwitch })
+  let dupCheckResult
+  if (!isTransferError) {
+    dupCheckResult = await Comparators.duplicateCheckComparator(transferId, payload, TransferService.getTransferFulfilmentDuplicateCheck, TransferService.saveTransferFulfilmentDuplicateCheck)
+  } else {
+    dupCheckResult = await Comparators.duplicateCheckComparator(transferId, payload, TransferService.getTransferErrorDuplicateCheck, TransferService.saveTransferErrorDuplicateCheck)
+  }
+  const { hasDuplicateId, hasDuplicateHash } = dupCheckResult
+  histTimerDuplicateCheckEnd({ success: true, funcName: 'fulfil_duplicateCheckComparator' })
+  if (hasDuplicateId && hasDuplicateHash) {
+    Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, 'handleResend'))
+
+    // This is a duplicate message for a transfer that is already in a finalized state
+    // respond as if we received a GET /transfers/{ID} from the client
+    if (transferStateEnum === TransferState.COMMITTED || transferStateEnum === TransferState.ABORTED) {
+      message.value.content.payload = TransferObjectTransform.toFulfil(transfer)
+      const eventDetail = { functionality, action }
+      if (action !== TransferEventAction.RESERVE) {
+        if (!isTransferError) {
+          Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackFinalized2--${actionLetter}3`))
+          eventDetail.action = TransferEventAction.FULFIL_DUPLICATE
+          /**
+           * HOWTO: During bulk fulfil use an individualTransfer from a previous bulk fulfil
+           */
+        } else {
+          Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackFinalized3--${actionLetter}4`))
+          eventDetail.action = TransferEventAction.ABORT_DUPLICATE
+        }
+      }
+      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail, fromSwitch, hubName: Config.HUB_NAME })
       histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
       return true
     }
 
-    // ERROR: We have seen a transfer of this ID before, but it's message hash doesn't match
-    // the previous message hash.
-    if (hasDuplicateId && !hasDuplicateHash) {
-      const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.MODIFIED_REQUEST)
-      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorModified2--${actionLetter}7`))
-      let action = TransferEventAction.FULFIL_DUPLICATE
-      if (isTransferError) {
-        action = TransferEventAction.ABORT_DUPLICATE
-      }
-
+    if (transferStateEnum === TransferState.RECEIVED || transferStateEnum === TransferState.RESERVED) {
+      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `inProgress2--${actionLetter}5`))
       /**
-       * HOWTO: During bulk fulfil use an individualTransfer from a previous bulk fulfil,
-       * but use different fulfilment value.
+       * HOWTO: Nearly impossible to trigger for bulk - an individual transfer from a bulk needs to be triggered
+       * for processing in order to have the fulfil duplicate hash recorded. While it is still in RESERVED state
+       * the individual transfer needs to be requested by another bulk fulfil request!
+       *
+       * TODO: find a way to trigger this code branch and handle it at BulkProcessingHandler (not in scope of #967)
        */
-      const eventDetail = { functionality, action }
-      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch })
-      throw fspiopError
+      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, histTimerEnd, hubName: Config.HUB_NAME })
+      histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
+      return true
     }
 
-    // Transfer is not a duplicate, or message hasn't been changed.
+    // Error scenario - transfer.transferStateEnumeration is in some invalid state
+    Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorInvalidTransferStateEnum--${actionLetter}6`))
+    const fspiopError = ErrorHandler.Factory.createInternalServerFSPIOPError(
+      `Invalid transferStateEnumeration:(${transferStateEnum}) for event action:(${action}) and type:(${type})`).toApiErrorObject(Config.ERROR_HANDLING)
+    const eventDetail = { functionality, action: TransferEventAction.COMMIT }
+    /**
+     * HOWTO: Impossible to trigger for individual transfer in a bulk? (not in scope of #967)
+     */
+    await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError, eventDetail, fromSwitch, hubName: Config.HUB_NAME })
+    histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
+    return true
+  }
 
-    if (type !== TransferEventType.FULFIL) {
-      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorInvalidEventType--${actionLetter}15`))
-      const fspiopError = ErrorHandler.Factory.createInternalServerFSPIOPError(`Invalid event type:(${type})`)
-      const eventDetail = { functionality, action: TransferEventAction.COMMIT }
-      /**
-       * TODO: BulkProcessingHandler (not in scope of #967)
-       */
-      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch })
-      throw fspiopError
+  // ERROR: We have seen a transfer of this ID before, but it's message hash doesn't match
+  // the previous message hash.
+  if (hasDuplicateId && !hasDuplicateHash) {
+    const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.MODIFIED_REQUEST)
+    Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorModified2--${actionLetter}7`))
+    let action = TransferEventAction.FULFIL_DUPLICATE
+    if (isTransferError) {
+      action = TransferEventAction.ABORT_DUPLICATE
     }
 
-    const validActions = [
-      TransferEventAction.COMMIT,
-      TransferEventAction.RESERVE,
-      TransferEventAction.REJECT,
-      TransferEventAction.ABORT,
-      TransferEventAction.BULK_COMMIT,
-      TransferEventAction.BULK_ABORT
-    ]
-    if (!validActions.includes(action)) {
-      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorInvalidEventAction--${actionLetter}15`))
-      const fspiopError = ErrorHandler.Factory.createInternalServerFSPIOPError(`Invalid event action:(${action}) and/or type:(${type})`)
-      const eventDetail = { functionality, action: TransferEventAction.COMMIT }
-      /**
-       * TODO: BulkProcessingHandler (not in scope of #967)
-       */
-      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch })
-      throw fspiopError
-    }
+    /**
+     * HOWTO: During bulk fulfil use an individualTransfer from a previous bulk fulfil,
+     * but use different fulfilment value.
+     */
+    const eventDetail = { functionality, action }
+    await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch, hubName: Config.HUB_NAME })
+    throw fspiopError
+  }
 
-    Util.breadcrumb(location, { path: 'validationCheck' })
-    if (payload.fulfilment && !Validator.validateFulfilCondition(payload.fulfilment, transfer.condition)) {
-      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorInvalidFulfilment--${actionLetter}9`))
-      const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.VALIDATION_ERROR, 'invalid fulfilment')
-      const apiFSPIOPError = fspiopError.toApiErrorObject(Config.ERROR_HANDLING)
-      await TransferService.handlePayeeResponse(transferId, payload, action, apiFSPIOPError)
-      const eventDetail = { functionality: TransferEventType.POSITION, action: TransferEventAction.ABORT_VALIDATION }
-      /**
-       * TODO: BulkProcessingHandler (not in scope of #967) The individual transfer is ABORTED by notification is never sent.
-       */
-      // Key position validation abort with payer account id
-      const payerAccount = await Participant.getAccountByNameAndCurrency(transfer.payerFsp, transfer.currency, Enum.Accounts.LedgerAccountType.POSITION)
-      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: apiFSPIOPError, eventDetail, messageKey: payerAccount.participantCurrencyId.toString() })
+  // Transfer is not a duplicate, or message hasn't been changed.
+
+  if (type !== TransferEventType.FULFIL) {
+    Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorInvalidEventType--${actionLetter}15`))
+    const fspiopError = ErrorHandler.Factory.createInternalServerFSPIOPError(`Invalid event type:(${type})`)
+    const eventDetail = { functionality, action: TransferEventAction.COMMIT }
+    /**
+     * TODO: BulkProcessingHandler (not in scope of #967)
+     */
+    await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch, hubName: Config.HUB_NAME })
+    throw fspiopError
+  }
 
-      // emit an extra message -  RESERVED_ABORTED if action === TransferEventAction.RESERVE
-      if (action === TransferEventAction.RESERVE) {
-        // Get the updated transfer now that completedTimestamp will be different
-        // TODO: should we just modify TransferService.handlePayeeResponse to
-        // return the completed timestamp? Or is it safer to go back to the DB here?
-        const transferAbortResult = await TransferService.getById(transferId)
-        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackReservedAborted--${actionLetter}1`))
-        const eventDetail = { functionality: TransferEventType.NOTIFICATION, action: TransferEventAction.RESERVED_ABORTED }
+  const validActions = [
+    TransferEventAction.COMMIT,
+    TransferEventAction.RESERVE,
+    TransferEventAction.REJECT,
+    TransferEventAction.ABORT,
+    TransferEventAction.BULK_COMMIT,
+    TransferEventAction.BULK_ABORT
+  ]
+  if (!validActions.includes(action)) {
+    Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorInvalidEventAction--${actionLetter}15`))
+    const fspiopError = ErrorHandler.Factory.createInternalServerFSPIOPError(`Invalid event action:(${action}) and/or type:(${type})`)
+    const eventDetail = { functionality, action: TransferEventAction.COMMIT }
+    /**
+     * TODO: BulkProcessingHandler (not in scope of #967)
+     */
+    await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch, hubName: Config.HUB_NAME })
+    throw fspiopError
+  }
 
-        // Extract error information
-        const errorCode = apiFSPIOPError && apiFSPIOPError.errorInformation && apiFSPIOPError.errorInformation.errorCode
-        const errorDescription = apiFSPIOPError && apiFSPIOPError.errorInformation && apiFSPIOPError.errorInformation.errorDescription
+  Util.breadcrumb(location, { path: 'validationCheck' })
+  if (payload.fulfilment && !Validator.validateFulfilCondition(payload.fulfilment, transfer.condition)) {
+    Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorInvalidFulfilment--${actionLetter}9`))
+    const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.VALIDATION_ERROR, 'invalid fulfilment')
+    const apiFSPIOPError = fspiopError.toApiErrorObject(Config.ERROR_HANDLING)
+    await TransferService.handlePayeeResponse(transferId, payload, TransferEventAction.ABORT_VALIDATION, apiFSPIOPError)
+    const eventDetail = { functionality: TransferEventType.POSITION, action: TransferEventAction.ABORT_VALIDATION }
+    /**
+     * TODO: BulkProcessingHandler (not in scope of #967) The individual transfer is ABORTED by notification is never sent.
+     */
+    // Key position validation abort with payer account id
+
+    const cyrilResult = await FxService.Cyril.processAbortMessage(transferId)
+
+    params.message.value.content.context = {
+      ...params.message.value.content.context,
+      cyrilResult
+    }
+    if (cyrilResult.positionChanges.length > 0) {
+      const participantCurrencyId = cyrilResult.positionChanges[0].participantCurrencyId
+      await Kafka.proceed(
+        Config.KAFKA_CONFIG,
+        params,
+        {
+          consumerCommit,
+          fspiopError: apiFSPIOPError,
+          eventDetail,
+          messageKey: participantCurrencyId.toString(),
+          topicNameOverride: Config.KAFKA_CONFIG.EVENT_TYPE_ACTION_TOPIC_MAP?.POSITION?.ABORT,
+          hubName: Config.HUB_NAME
+        }
+      )
+    } else {
+      const fspiopError = ErrorHandler.Factory.createInternalServerFSPIOPError('Invalid cyril result')
+      throw fspiopError
+    }
 
-        // TODO: This should be handled by a PATCH /transfers/{id}/error callback in the future FSPIOP v1.2 specification, and instead we should just send the FSPIOP-Error instead! Ref: https://github.com/mojaloop/mojaloop-specification/issues/106.
-        const reservedAbortedPayload = {
-          transferId: transferAbortResult && transferAbortResult.id,
-          completedTimestamp: transferAbortResult && transferAbortResult.completedTimestamp && (new Date(Date.parse(transferAbortResult.completedTimestamp))).toISOString(),
-          transferState: TransferState.ABORTED,
-          extensionList: { // lets add the extension list to handle the limitation of the FSPIOP v1.1 specification by adding the error cause...
-            extension: [
-              {
-                key: 'cause',
-                value: `${errorCode}: ${errorDescription}`
-              }
-            ]
-          }
+    // const payerAccount = await Participant.getAccountByNameAndCurrency(transfer.payerFsp, transfer.currency, Enum.Accounts.LedgerAccountType.POSITION)
+    // await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: apiFSPIOPError, eventDetail, messageKey: payerAccount.participantCurrencyId.toString(), hubName: Config.HUB_NAME })
+
+    // emit an extra message -  RESERVED_ABORTED if action === TransferEventAction.RESERVE
+    if (action === TransferEventAction.RESERVE) {
+      // Get the updated transfer now that completedTimestamp will be different
+      // TODO: should we just modify TransferService.handlePayeeResponse to
+      // return the completed timestamp? Or is it safer to go back to the DB here?
+      const transferAbortResult = await TransferService.getById(transferId)
+      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackReservedAborted--${actionLetter}1`))
+      const eventDetail = { functionality: TransferEventType.NOTIFICATION, action: TransferEventAction.RESERVED_ABORTED }
+
+      // Extract error information
+      const errorCode = apiFSPIOPError && apiFSPIOPError.errorInformation && apiFSPIOPError.errorInformation.errorCode
+      const errorDescription = apiFSPIOPError && apiFSPIOPError.errorInformation && apiFSPIOPError.errorInformation.errorDescription
+
+      // TODO: This should be handled by a PATCH /transfers/{id}/error callback in the future FSPIOP v1.2 specification, and instead we should just send the FSPIOP-Error instead! Ref: https://github.com/mojaloop/mojaloop-specification/issues/106.
+      const reservedAbortedPayload = {
+        transferId: transferAbortResult && transferAbortResult.id,
+        completedTimestamp: transferAbortResult && transferAbortResult.completedTimestamp && (new Date(Date.parse(transferAbortResult.completedTimestamp))).toISOString(),
+        transferState: TransferState.ABORTED,
+        extensionList: { // lets add the extension list to handle the limitation of the FSPIOP v1.1 specification by adding the error cause...
+          extension: [
+            {
+              key: 'cause',
+              value: `${errorCode}: ${errorDescription}`
+            }
+          ]
         }
-        message.value.content.payload = reservedAbortedPayload
-        await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail, fromSwitch: true, toDestination: transfer.payeeFsp })
       }
-      throw fspiopError
+      message.value.content.payload = reservedAbortedPayload
+      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail, fromSwitch: true, toDestination: transfer.payeeFsp, hubName: Config.HUB_NAME })
     }
+    throw fspiopError
+  }
 
-    if (transfer.transferState !== TransferState.RESERVED) {
-      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorNonReservedState--${actionLetter}10`))
-      const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.VALIDATION_ERROR, 'non-RESERVED transfer state')
-      const eventDetail = { functionality, action: TransferEventAction.COMMIT }
-      /**
-       * TODO: BulkProcessingHandler (not in scope of #967)
-       */
-      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch })
+  if (transfer.transferState !== Enum.Transfers.TransferInternalState.RESERVED &&
+      transfer.transferState !== Enum.Transfers.TransferInternalState.RESERVED_FORWARDED
+  ) {
+    Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorNonReservedState--${actionLetter}10`))
+    const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.VALIDATION_ERROR, 'non-RESERVED transfer state')
+    const eventDetail = { functionality, action: TransferEventAction.COMMIT }
+    /**
+     * TODO: BulkProcessingHandler (not in scope of #967)
+     */
+    await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch, hubName: Config.HUB_NAME })
+
+    // emit an extra message -  RESERVED_ABORTED if action === TransferEventAction.RESERVE
+    if (action === TransferEventAction.RESERVE) {
+      // Get the updated transfer now that completedTimestamp will be different
+      // TODO: should we just modify TransferService.handlePayeeResponse to
+      // return the completed timestamp? Or is it safer to go back to the DB here?
+      const transferAborted = await TransferService.getById(transferId) // TODO: remove this once it can be tested
+      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackReservedAborted--${actionLetter}2`))
+      const eventDetail = { functionality: TransferEventType.NOTIFICATION, action: TransferEventAction.RESERVED_ABORTED }
+      const reservedAbortedPayload = {
+        transferId: transferAborted.id,
+        completedTimestamp: Util.Time.getUTCString(new Date(transferAborted.completedTimestamp)), // TODO: remove this once it can be tested
+        transferState: TransferState.ABORTED
+      }
+      message.value.content.payload = reservedAbortedPayload
+      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail, fromSwitch: true, toDestination: transfer.payeeFsp, hubName: Config.HUB_NAME })
+    }
+    throw fspiopError
+  }
 
-      // emit an extra message -  RESERVED_ABORTED if action === TransferEventAction.RESERVE
-      if (action === TransferEventAction.RESERVE) {
-        // Get the updated transfer now that completedTimestamp will be different
-        // TODO: should we just modify TransferService.handlePayeeResponse to
-        // return the completed timestamp? Or is it safer to go back to the DB here?
-        const transferAborted = await TransferService.getById(transferId) // TODO: remove this once it can be tested
-        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackReservedAborted--${actionLetter}2`))
-        const eventDetail = { functionality: TransferEventType.NOTIFICATION, action: TransferEventAction.RESERVED_ABORTED }
-        const reservedAbortedPayload = {
-          transferId: transferAborted.id,
-          completedTimestamp: Util.Time.getUTCString(new Date(transferAborted.completedTimestamp)), // TODO: remove this once it can be tested
-          transferState: TransferState.ABORTED
-        }
-        message.value.content.payload = reservedAbortedPayload
-        await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail, fromSwitch: true, toDestination: transfer.payeeFsp })
+  if (transfer.expirationDate <= new Date(Util.Time.getUTCString(new Date()))) {
+    Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorTransferExpired--${actionLetter}11`))
+    const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.TRANSFER_EXPIRED)
+    const eventDetail = { functionality, action: TransferEventAction.COMMIT }
+    /**
+     * TODO: BulkProcessingHandler (not in scope of #967)
+     */
+    await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch, hubName: Config.HUB_NAME })
+
+    // emit an extra message -  RESERVED_ABORTED if action === TransferEventAction.RESERVE
+    if (action === TransferEventAction.RESERVE) {
+      // Get the updated transfer now that completedTimestamp will be different
+      // TODO: should we just modify TransferService.handlePayeeResponse to
+      // return the completed timestamp? Or is it safer to go back to the DB here?
+      const transferAborted = await TransferService.getById(transferId)
+      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackReservedAborted--${actionLetter}3`))
+      const eventDetail = { functionality: TransferEventType.NOTIFICATION, action: TransferEventAction.RESERVED_ABORTED }
+      const reservedAbortedPayload = {
+        transferId: transferAborted.id,
+        completedTimestamp: Util.Time.getUTCString(new Date(transferAborted.completedTimestamp)),
+        transferState: TransferState.ABORTED
       }
-      throw fspiopError
+      message.value.content.payload = reservedAbortedPayload
+      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail, fromSwitch: true, hubName: Config.HUB_NAME })
     }
+    throw fspiopError
+  }
 
-    if (transfer.expirationDate <= new Date(Util.Time.getUTCString(new Date()))) {
-      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorTransferExpired--${actionLetter}11`))
-      const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.TRANSFER_EXPIRED)
-      const eventDetail = { functionality, action: TransferEventAction.COMMIT }
-      /**
-       * TODO: BulkProcessingHandler (not in scope of #967)
-       */
-      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch })
+  // Validations Succeeded - process the fulfil
+  Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, { path: 'validationPassed' }))
+  switch (action) {
+    case TransferEventAction.COMMIT:
+    case TransferEventAction.RESERVE:
+    case TransferEventAction.BULK_COMMIT: {
+      let topicNameOverride
+      if (action === TransferEventAction.COMMIT) {
+        topicNameOverride = Config.KAFKA_CONFIG.EVENT_TYPE_ACTION_TOPIC_MAP?.POSITION?.COMMIT
+      } else if (action === TransferEventAction.RESERVE) {
+        topicNameOverride = Config.KAFKA_CONFIG.EVENT_TYPE_ACTION_TOPIC_MAP?.POSITION?.RESERVE
+      } else if (action === TransferEventAction.BULK_COMMIT) {
+        topicNameOverride = Config.KAFKA_CONFIG.EVENT_TYPE_ACTION_TOPIC_MAP?.POSITION?.BULK_COMMIT
+      }
 
-      // emit an extra message -  RESERVED_ABORTED if action === TransferEventAction.RESERVE
-      if (action === TransferEventAction.RESERVE) {
-        // Get the updated transfer now that completedTimestamp will be different
-        // TODO: should we just modify TransferService.handlePayeeResponse to
-        // return the completed timestamp? Or is it safer to go back to the DB here?
-        const transferAborted = await TransferService.getById(transferId)
-        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackReservedAborted--${actionLetter}3`))
-        const eventDetail = { functionality: TransferEventType.NOTIFICATION, action: TransferEventAction.RESERVED_ABORTED }
-        const reservedAbortedPayload = {
-          transferId: transferAborted.id,
-          completedTimestamp: Util.Time.getUTCString(new Date(transferAborted.completedTimestamp)),
-          transferState: TransferState.ABORTED
+      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `positionTopic2--${actionLetter}12`))
+      await TransferService.handlePayeeResponse(transferId, payload, action)
+      const eventDetail = { functionality: TransferEventType.POSITION, action }
+      // Key position fulfil message with payee account id
+      const cyrilResult = await FxService.Cyril.processFulfilMessage(transferId, payload, transfer)
+      if (cyrilResult.isFx) {
+        // const payeeAccount = await Participant.getAccountByNameAndCurrency(transfer.payeeFsp, transfer.currency, Enum.Accounts.LedgerAccountType.POSITION)
+        params.message.value.content.context = {
+          ...params.message.value.content.context,
+          cyrilResult
         }
-        message.value.content.payload = reservedAbortedPayload
-        await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail, fromSwitch: true })
+        if (cyrilResult.positionChanges.length > 0) {
+          const participantCurrencyId = cyrilResult.positionChanges[0].participantCurrencyId
+          await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail, messageKey: participantCurrencyId.toString(), topicNameOverride, hubName: Config.HUB_NAME })
+          histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
+        } else {
+          histTimerEnd({ success: false, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
+          const fspiopError = ErrorHandler.Factory.createInternalServerFSPIOPError('Invalid cyril result')
+          throw fspiopError
+        }
+      } else {
+        const payeeAccount = await Participant.getAccountByNameAndCurrency(transfer.payeeFsp, transfer.currency, Enum.Accounts.LedgerAccountType.POSITION)
+        await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail, messageKey: payeeAccount.participantCurrencyId.toString(), topicNameOverride, hubName: Config.HUB_NAME })
+        histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
+      }
+      return true
+    }
+    // TODO: why do we let this logic get this far? Why not remove it from validActions array above?
+    case TransferEventAction.REJECT: {
+      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `positionTopic3--${actionLetter}13`))
+      const errorMessage = 'action REJECT is not allowed into fulfil handler'
+      Logger.isErrorEnabled && Logger.error(errorMessage)
+      !!span && span.error(errorMessage)
+      histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
+      return true
+    }
+    case TransferEventAction.BULK_ABORT: {
+      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `positionTopic4--${actionLetter}14`))
+      let fspiopError
+      const eInfo = payload.errorInformation
+      try { // handle only valid errorCodes provided by the payee
+        fspiopError = ErrorHandler.Factory.createFSPIOPErrorFromErrorInformation(eInfo)
+      } catch (err) {
+        /**
+         * TODO: Handling of out-of-range errorCodes is to be introduced to the ml-api-adapter,
+         * so that such requests are rejected right away, instead of aborting the transfer here.
+         */
+        Logger.isErrorEnabled && Logger.error(`${Util.breadcrumb(location)}::${err.message}`)
+        fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.VALIDATION_ERROR, 'API specification undefined errorCode')
+        await TransferService.handlePayeeResponse(transferId, payload, action, fspiopError.toApiErrorObject(Config.ERROR_HANDLING))
+        const eventDetail = { functionality: TransferEventType.POSITION, action }
+        // Key position abort with payer account id
+        const payerAccount = await Participant.getAccountByNameAndCurrency(transfer.payerFsp, transfer.currency, Enum.Accounts.LedgerAccountType.POSITION)
+        await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, messageKey: payerAccount.participantCurrencyId.toString(), hubName: Config.HUB_NAME })
+        throw fspiopError
       }
+      await TransferService.handlePayeeResponse(transferId, payload, action, fspiopError.toApiErrorObject(Config.ERROR_HANDLING))
+      const eventDetail = { functionality: TransferEventType.POSITION, action }
+      // Key position abort with payer account id
+      const payerAccount = await Participant.getAccountByNameAndCurrency(transfer.payerFsp, transfer.currency, Enum.Accounts.LedgerAccountType.POSITION)
+      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, messageKey: payerAccount.participantCurrencyId.toString(), hubName: Config.HUB_NAME })
+      // TODO(2556): I don't think we should emit an extra notification here
+      // this is the case where the Payee sent an ABORT, so we don't need to tell them to abort
       throw fspiopError
     }
-
-    // Validations Succeeded - process the fulfil
-    Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, { path: 'validationPassed' }))
-    switch (action) {
-      case TransferEventAction.COMMIT:
-      case TransferEventAction.RESERVE:
-      case TransferEventAction.BULK_COMMIT: {
-        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `positionTopic2--${actionLetter}12`))
-        await TransferService.handlePayeeResponse(transferId, payload, action)
+    case TransferEventAction.ABORT: {
+      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `positionTopic4--${actionLetter}14`))
+      let fspiopError
+      const eInfo = payload.errorInformation
+      try { // handle only valid errorCodes provided by the payee
+        fspiopError = ErrorHandler.Factory.createFSPIOPErrorFromErrorInformation(eInfo)
+      } catch (err) {
+        /**
+         * TODO: Handling of out-of-range errorCodes is to be introduced to the ml-api-adapter,
+         * so that such requests are rejected right away, instead of aborting the transfer here.
+         */
+        Logger.isErrorEnabled && Logger.error(`${Util.breadcrumb(location)}::${err.message}`)
+        fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.VALIDATION_ERROR, 'API specification undefined errorCode')
+        await TransferService.handlePayeeResponse(transferId, payload, action, fspiopError.toApiErrorObject(Config.ERROR_HANDLING))
         const eventDetail = { functionality: TransferEventType.POSITION, action }
-        // Key position fulfil message with payee account id
-        let topicNameOverride
-        if (action === TransferEventAction.COMMIT) {
-          topicNameOverride = Config.KAFKA_CONFIG.EVENT_TYPE_ACTION_TOPIC_MAP?.POSITION?.COMMIT
-        } else if (action === TransferEventAction.RESERVE) {
-          topicNameOverride = Config.KAFKA_CONFIG.EVENT_TYPE_ACTION_TOPIC_MAP?.POSITION?.RESERVE
-        } else if (action === TransferEventAction.BULK_COMMIT) {
-          topicNameOverride = Config.KAFKA_CONFIG.EVENT_TYPE_ACTION_TOPIC_MAP?.POSITION?.BULK_COMMIT
-        }
-        const payeeAccount = await Participant.getAccountByNameAndCurrency(transfer.payeeFsp, transfer.currency, Enum.Accounts.LedgerAccountType.POSITION)
+        // Key position abort with payer account id
+        const payerAccount = await Participant.getAccountByNameAndCurrency(transfer.payerFsp, transfer.currency, Enum.Accounts.LedgerAccountType.POSITION)
+        await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, messageKey: payerAccount.participantCurrencyId.toString(), hubName: Config.HUB_NAME })
+        throw fspiopError
+      }
+      await TransferService.handlePayeeResponse(transferId, payload, action, fspiopError.toApiErrorObject(Config.ERROR_HANDLING))
+      const eventDetail = { functionality: TransferEventType.POSITION, action }
+      const cyrilResult = await FxService.Cyril.processAbortMessage(transferId)
+
+      params.message.value.content.context = {
+        ...params.message.value.content.context,
+        cyrilResult
+      }
+      if (cyrilResult.positionChanges.length > 0) {
+        const participantCurrencyId = cyrilResult.positionChanges[0].participantCurrencyId
         await Kafka.proceed(
           Config.KAFKA_CONFIG,
           params,
           {
             consumerCommit,
+            fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING),
             eventDetail,
-            messageKey: payeeAccount.participantCurrencyId.toString(),
-            topicNameOverride
+            messageKey: participantCurrencyId.toString(),
+            topicNameOverride: Config.KAFKA_CONFIG.EVENT_TYPE_ACTION_TOPIC_MAP?.POSITION?.ABORT,
+            hubName: Config.HUB_NAME
           }
         )
-        histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
-        return true
-      }
-      // TODO: why do we let this logic get this far? Why not remove it from validActions array above?
-      case TransferEventAction.REJECT: {
-        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `positionTopic3--${actionLetter}13`))
-        const errorMessage = 'action REJECT is not allowed into fulfil handler'
-        Logger.isErrorEnabled && Logger.error(errorMessage)
-        !!span && span.error(errorMessage)
-        histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
-        return true
-      }
-      // TODO: why do we let this logic get this far? Why not remove it from validActions array above?
-      case TransferEventAction.ABORT:
-      case TransferEventAction.BULK_ABORT:
-      default: { // action === TransferEventAction.ABORT || action === TransferEventAction.BULK_ABORT // error-callback request to be processed
-        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `positionTopic4--${actionLetter}14`))
-        let fspiopError
-        const eInfo = payload.errorInformation
-        try { // handle only valid errorCodes provided by the payee
-          fspiopError = ErrorHandler.Factory.createFSPIOPErrorFromErrorInformation(eInfo)
-        } catch (err) {
-          /**
-           * TODO: Handling of out-of-range errorCodes is to be introduced to the ml-api-adapter,
-           * so that such requests are rejected right away, instead of aborting the transfer here.
-           */
-          Logger.isErrorEnabled && Logger.error(`${Util.breadcrumb(location)}::${err.message}`)
-          fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.VALIDATION_ERROR, 'API specification undefined errorCode')
-          await TransferService.handlePayeeResponse(transferId, payload, action, fspiopError.toApiErrorObject(Config.ERROR_HANDLING))
-          const eventDetail = { functionality: TransferEventType.POSITION, action }
-          // Key position abort with payer account id
-          const payerAccount = await Participant.getAccountByNameAndCurrency(transfer.payerFsp, transfer.currency, Enum.Accounts.LedgerAccountType.POSITION)
-          await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, messageKey: payerAccount.participantCurrencyId.toString() })
-          throw fspiopError
-        }
-        await TransferService.handlePayeeResponse(transferId, payload, action, fspiopError.toApiErrorObject(Config.ERROR_HANDLING))
-        const eventDetail = { functionality: TransferEventType.POSITION, action }
-        // Key position abort with payer account id
-        const payerAccount = await Participant.getAccountByNameAndCurrency(transfer.payerFsp, transfer.currency, Enum.Accounts.LedgerAccountType.POSITION)
-        await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, messageKey: payerAccount.participantCurrencyId.toString() })
-        // TODO(2556): I don't think we should emit an extra notification here
-        // this is the case where the Payee sent an ABORT, so we don't need to tell them to abort
+      } else {
+        const fspiopError = ErrorHandler.Factory.createInternalServerFSPIOPError('Invalid cyril result')
         throw fspiopError
       }
     }
-  } catch (err) {
-    histTimerEnd({ success: false, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
-    const fspiopError = ErrorHandler.Factory.reformatFSPIOPError(err)
-    Logger.isErrorEnabled && Logger.error(`${Util.breadcrumb(location)}::${err.message}--F0`)
-    const state = new EventSdk.EventStateMetadata(EventSdk.EventStatusType.failed, fspiopError.apiErrorCode.code, fspiopError.apiErrorCode.message)
-    await span.error(fspiopError, state)
-    await span.finish(fspiopError.message, state)
+  }
+}
+
+const processFxFulfilMessage = async (message, functionality, span) => {
+  const histTimerEnd = Metrics.getHistogram(
+    'fx_transfer_fulfil',
+    'Consume a fx fulfil transfer message from the kafka topic and process it accordingly',
+    ['success', 'fspId']
+  ).startTimer()
+
+  const {
+    payload,
+    headers,
+    type,
+    action,
+    commitRequestId,
+    kafkaTopic
+  } = FxFulfilService.decodeKafkaMessage(message)
+
+  const log = logger.child({ commitRequestId, type, action })
+  log.info('processFxFulfilMessage start...', { payload })
+
+  const params = {
+    message,
+    kafkaTopic,
+    span,
+    decodedPayload: payload,
+    consumer: Consumer,
+    producer: Producer
+  }
+
+  const fxFulfilService = new FxFulfilService({
+    log, Config, Comparators, Validator, FxTransferModel, Kafka, params
+  })
+
+  // Validate event type
+  await fxFulfilService.validateEventType(type, functionality)
+
+  // Validate action
+  const validActions = [
+    TransferEventAction.FX_RESERVE,
+    TransferEventAction.FX_COMMIT,
+    // TransferEventAction.FX_REJECT,
+    TransferEventAction.FX_ABORT,
+    TransferEventAction.FX_FORWARDED
+  ]
+  if (!validActions.includes(action)) {
+    const errorMessage = ERROR_MESSAGES.fxActionIsNotAllowed(action)
+    log.error(errorMessage)
+    span?.error(errorMessage)
+    histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
     return true
-  } finally {
-    if (!span.isFinished) {
-      await span.finish()
+  }
+
+  const transfer = await fxFulfilService.getFxTransferDetails(commitRequestId, functionality)
+  // todo: rename to fxTransfer
+  await fxFulfilService.validateHeaders({ transfer, headers, payload })
+
+  // If execution continues after this point we are sure fxTransfer exists and source matches payee fsp
+  const histTimerDuplicateCheckEnd = Metrics.getHistogram(
+    'fx_handler_transfers',
+    'fxFulfil_duplicateCheckComparator - Metrics for fxTransfer handler',
+    ['success', 'funcName']
+  ).startTimer()
+
+  const dupCheckResult = await fxFulfilService.getDuplicateCheckResult({ commitRequestId, payload })
+  histTimerDuplicateCheckEnd({ success: true, funcName: 'fxFulfil_duplicateCheckComparator' })
+
+  const isDuplicate = await fxFulfilService.checkDuplication({ dupCheckResult, transfer, functionality, action, type })
+  if (isDuplicate) {
+    log.info('fxTransfer duplication detected, skip further processing')
+    histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
+    return true
+  }
+
+  // Transfer is not a duplicate, or message hasn't been changed.
+
+  payload.fulfilment && await fxFulfilService.validateFulfilment(transfer, payload)
+  await fxFulfilService.validateTransferState(transfer, functionality)
+  await fxFulfilService.validateExpirationDate(transfer, functionality)
+
+  log.info('Validations Succeeded - process the fxFulfil...')
+
+  switch (action) {
+    case TransferEventAction.FX_RESERVE:
+    case TransferEventAction.FX_COMMIT: {
+      const success = await fxFulfilService.processFxFulfil({ transfer, payload, action })
+      log.info('fxFulfil handling is done', { success })
+      histTimerEnd({ success, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
+      return success
+    }
+    case TransferEventAction.FX_ABORT: {
+      const success = await fxFulfilService.processFxAbort({ transfer, payload, action })
+      log.info('fxAbort handling is done', { success })
+      histTimerEnd({ success, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
+      return true
     }
   }
 }
@@ -769,46 +786,66 @@ const getTransfer = async (error, messages) => {
   } else {
     message = messages
   }
+  const action = message.value.metadata.event.action
+  const isFx = action === TransferEventAction.FX_GET
   const contextFromMessage = EventSdk.Tracer.extractContextFromMessage(message.value)
   const span = EventSdk.Tracer.createChildSpanFromContext('cl_transfer_get', contextFromMessage)
   try {
     await span.audit(message, EventSdk.AuditEventAction.start)
     const metadata = message.value.metadata
     const action = metadata.event.action
-    const transferId = message.value.content.uriParams.id
+    const transferIdOrCommitRequestId = message.value.content.uriParams.id
     const kafkaTopic = message.topic
     Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, { method: `getTransfer:${action}` }))
 
     const actionLetter = Enum.Events.ActionLetter.get
     const params = { message, kafkaTopic, span, consumer: Consumer, producer: Producer }
-    const eventDetail = { functionality: TransferEventType.NOTIFICATION, action: TransferEventAction.GET }
+    const eventDetail = { functionality: TransferEventType.NOTIFICATION, action }
 
     Util.breadcrumb(location, { path: 'validationFailed' })
     if (!await Validator.validateParticipantByName(message.value.from)) {
       Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `breakParticipantDoesntExist--${actionLetter}1`))
-      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, histTimerEnd })
+      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, histTimerEnd, hubName: Config.HUB_NAME })
       histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
       return true
     }
-    const transfer = await TransferService.getByIdLight(transferId)
-    if (!transfer) {
-      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorTransferNotFound--${actionLetter}3`))
-      const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.TRANSFER_ID_NOT_FOUND, 'Provided Transfer ID was not found on the server.')
-      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch })
-      throw fspiopError
-    }
-    if (!await Validator.validateParticipantTransferId(message.value.from, transferId)) {
-      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorNotTransferParticipant--${actionLetter}2`))
-      const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.CLIENT_ERROR)
-      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch })
-      throw fspiopError
+    if (isFx) {
+      const fxTransfer = await FxTransferModel.fxTransfer.getByIdLight(transferIdOrCommitRequestId)
+      if (!fxTransfer) {
+        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorTransferNotFound--${actionLetter}3`))
+        const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.TRANSFER_ID_NOT_FOUND, 'Provided commitRequest ID was not found on the server.')
+        await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch, hubName: Config.HUB_NAME })
+        throw fspiopError
+      }
+      if (!await Validator.validateParticipantForCommitRequestId(message.value.from, transferIdOrCommitRequestId)) {
+        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorNotFxTransferParticipant--${actionLetter}2`))
+        const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.CLIENT_ERROR)
+        await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch, hubName: Config.HUB_NAME })
+        throw fspiopError
+      }
+      Util.breadcrumb(location, { path: 'validationPassed' })
+      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackMessage--${actionLetter}4`))
+      message.value.content.payload = TransferObjectTransform.toFulfil(fxTransfer, true)
+    } else {
+      const transfer = await TransferService.getByIdLight(transferIdOrCommitRequestId)
+      if (!transfer) {
+        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorTransferNotFound--${actionLetter}3`))
+        const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.TRANSFER_ID_NOT_FOUND, 'Provided Transfer ID was not found on the server.')
+        await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch, hubName: Config.HUB_NAME })
+        throw fspiopError
+      }
+      if (!await Validator.validateParticipantTransferId(message.value.from, transferIdOrCommitRequestId)) {
+        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorNotTransferParticipant--${actionLetter}2`))
+        const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.CLIENT_ERROR)
+        await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch, hubName: Config.HUB_NAME })
+        throw fspiopError
+      }
+      Util.breadcrumb(location, { path: 'validationPassed' })
+      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackMessage--${actionLetter}4`))
+      message.value.content.payload = TransferObjectTransform.toFulfil(transfer)
     }
 
-    // ============================================================================================
-    Util.breadcrumb(location, { path: 'validationPassed' })
-    Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackMessage--${actionLetter}4`))
-    message.value.content.payload = TransferObjectTransform.toFulfil(transfer)
-    await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail, fromSwitch })
+    await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail, fromSwitch, hubName: Config.HUB_NAME })
     histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
     return true
   } catch (err) {
@@ -836,13 +873,14 @@ const getTransfer = async (error, messages) => {
  */
 const registerPrepareHandler = async () => {
   try {
-    const prepareHandler = {
-      command: prepare,
-      topicName: Kafka.transformGeneralTopicName(Config.KAFKA_CONFIG.TOPIC_TEMPLATES.GENERAL_TOPIC_TEMPLATE.TEMPLATE, TransferEventType.TRANSFER, TransferEventAction.PREPARE),
-      config: Kafka.getKafkaConfig(Config.KAFKA_CONFIG, Enum.Kafka.Config.CONSUMER, TransferEventType.TRANSFER.toUpperCase(), TransferEventAction.PREPARE.toUpperCase())
-    }
-    prepareHandler.config.rdkafkaConf['client.id'] = prepareHandler.topicName
-    await Consumer.createHandler(prepareHandler.topicName, prepareHandler.config, prepareHandler.command)
+    const { TRANSFER } = TransferEventType
+    const { PREPARE } = TransferEventAction
+
+    const topicName = Kafka.transformGeneralTopicName(Config.KAFKA_CONFIG.TOPIC_TEMPLATES.GENERAL_TOPIC_TEMPLATE.TEMPLATE, TRANSFER, PREPARE)
+    const consumeConfig = Kafka.getKafkaConfig(Config.KAFKA_CONFIG, Enum.Kafka.Config.CONSUMER, TRANSFER.toUpperCase(), PREPARE.toUpperCase())
+    consumeConfig.rdkafkaConf['client.id'] = topicName
+
+    await Consumer.createHandler(topicName, consumeConfig, prepare)
     return true
   } catch (err) {
     Logger.isErrorEnabled && Logger.error(err)