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

package/src/handlers/transfers/handler.js

@@ -24,6 +24,7 @@
 
  * ModusBox
  - Georgi Georgiev <georgi.georgiev@modusbox.com>
+ - Georgi Logodazhki <georgi.logodazhki@modusbox.com>
  - Rajiv Mothilal <rajiv.mothilal@modusbox.com>
  - Miguel de Barros <miguel.debarros@modusbox.com>
  - Deon Botha <deon.botha@modusbox.com>
@@ -52,7 +53,7 @@ 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 = require('@mojaloop/central-services-shared').Util.StreamingProtocol.decodePayload
+const decodePayload = Util.StreamingProtocol.decodePayload
 const Comparators = require('@mojaloop/central-services-shared').Util.Comparators
 const ErrorHandler = require('@mojaloop/central-services-error-handling')
 
@@ -70,7 +71,7 @@ const toDestination = true
  * 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.validateByName called to validate the payload of the message
+ * 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
@@ -109,69 +110,80 @@ const prepare = async (error, messages) => {
     span.setTags({ transactionId: transferId })
     await span.audit(message, EventSdk.AuditEventAction.start)
     const kafkaTopic = message.topic
-    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)
+    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.info(Util.breadcrumb(location, { path: 'dupCheck' }))
+    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.info(Util.breadcrumb(location, 'handleResend'))
+      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.info(Util.breadcrumb(location, 'finalized'))
+        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, 'finalized'))
         if (action === TransferEventAction.PREPARE) {
-          Logger.info(Util.breadcrumb(location, `callback--${actionLetter}1`))
+          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.info(Util.breadcrumb(location, `validationError1--${actionLetter}2`))
+          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.info(Util.breadcrumb(location, 'inProgress'))
+        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, 'inProgress'))
         if (action === TransferEventAction.BULK_PREPARE) {
-          Logger.info(Util.breadcrumb(location, `validationError2--${actionLetter}4`))
+          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.info(Util.breadcrumb(location, `ignore--${actionLetter}3`))
+          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.error(Util.breadcrumb(location, `callbackErrorModified1--${actionLetter}5`))
+      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.validateByName(payload, headers)
+      const { validationPassed, reasons } = await Validator.validatePrepare(payload, headers)
       if (validationPassed) {
-        Logger.info(Util.breadcrumb(location, { path: 'validationPassed' }))
+        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, { path: 'validationPassed' }))
         try {
-          Logger.info(Util.breadcrumb(location, 'saveTransfer'))
+          Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, 'saveTransfer'))
           await TransferService.prepare(payload)
         } catch (err) {
-          Logger.info(Util.breadcrumb(location, `callbackErrorInternal1--${actionLetter}6`))
-          Logger.error(`${Util.breadcrumb(location)}::${err.message}`)
+          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 }
           /**
@@ -179,23 +191,24 @@ const prepare = async (error, messages) => {
            * 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.info(Util.breadcrumb(location, `positionTopic1--${actionLetter}7`))
+        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `positionTopic1--${actionLetter}7`))
         functionality = TransferEventType.POSITION
         const eventDetail = { functionality, action }
         await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail, toDestination })
         histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
         return true
       } else {
-        Logger.error(Util.breadcrumb(location, { path: 'validationFailed' }))
+        Logger.isErrorEnabled && Logger.error(Util.breadcrumb(location, { path: 'validationFailed' }))
         try {
-          Logger.info(Util.breadcrumb(location, 'saveInvalidRequest'))
+          Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, 'saveInvalidRequest'))
           await TransferService.prepare(payload, reasons.toString(), false)
         } catch (err) {
-          Logger.info(Util.breadcrumb(location, `callbackErrorInternal2--${actionLetter}8`))
-          Logger.error(`${Util.breadcrumb(location)}::${err.message}`)
+          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 }
           /**
@@ -208,7 +221,7 @@ const prepare = async (error, messages) => {
           await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch })
           throw fspiopError
         }
-        Logger.info(Util.breadcrumb(location, `callbackErrorGeneric--${actionLetter}9`))
+        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 }
@@ -225,7 +238,7 @@ const prepare = async (error, messages) => {
   } catch (err) {
     histTimerEnd({ success: false, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
     const fspiopError = ErrorHandler.Factory.reformatFSPIOPError(err)
-    Logger.error(`${Util.breadcrumb(location)}::${err.message}--P0`)
+    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)
@@ -263,28 +276,56 @@ const fulfil = async (error, messages) => {
     const action = message.value.metadata.event.action
     const transferId = message.value.content.uriParams.id
     const kafkaTopic = message.topic
-    Logger.info(Util.breadcrumb(location, { method: `fulfil:${action}` }))
-
-    const actionLetter = action === TransferEventAction.COMMIT ? Enum.Events.ActionLetter.commit
-      : (action === TransferEventAction.REJECT ? Enum.Events.ActionLetter.reject
-        : (action === TransferEventAction.ABORT ? Enum.Events.ActionLetter.abort
-          : (action === TransferEventAction.BULK_COMMIT ? Enum.Events.ActionLetter.bulkCommit
-            : Enum.Events.ActionLetter.unknown)))
-    const functionality = action === TransferEventAction.COMMIT ? TransferEventType.NOTIFICATION
-      : (action === TransferEventAction.REJECT ? TransferEventType.NOTIFICATION
-        : (action === TransferEventAction.ABORT ? TransferEventType.NOTIFICATION
-          : (action === TransferEventAction.BULK_COMMIT ? TransferEventType.BULK_PROCESSING
-            : Enum.Events.ActionLetter.unknown)))
+    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 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.info(Util.breadcrumb(location, { path: 'getById' }))
+    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 transfer = await TransferService.getById(transferId)
     const transferStateEnum = transfer && transfer.transferStateEnumeration
 
     if (!transfer) {
-      Logger.error(Util.breadcrumb(location, `callbackInternalServerErrorNotFound--${actionLetter}1`))
+      Logger.isErrorEnabled && Logger.error(Util.breadcrumb(location, `callbackInternalServerErrorNotFound--${actionLetter}1`))
       const fspiopError = ErrorHandler.Factory.createInternalServerFSPIOPError('transfer not found')
       const eventDetail = { functionality, action: TransferEventAction.COMMIT }
       /**
@@ -294,28 +335,91 @@ const fulfil = async (error, messages) => {
        */
       await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch })
       throw fspiopError
-    } else if (headers[Enum.Http.Headers.FSPIOP.SOURCE].toLowerCase() !== transfer.payeeFsp.toLowerCase()) {
+
+      // Lets validate FSPIOP Source & Destination Headers
+    } else if ((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()))) {
       /**
-       * If fulfilment request is coming from a source not matching transfer payee fsp,
-       * don't proceed the request, but rather send error callback to original payee fsp.
-       * This is also the reason why we need to retrieve the transfer info upfront now.
+       * If fulfilment request is coming from a source not matching transfer payee fsp or destination not matching transfer payer fsp,
        */
-      Logger.info(Util.breadcrumb(location, `callbackErrorSourceNotMatchingPayeeFsp--${actionLetter}2`))
-      const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.VALIDATION_ERROR, `${Enum.Http.Headers.FSPIOP.SOURCE} does not match payee fsp`)
-      const toDestination = transfer.payeeFsp // overrding global boolean declaration with a string value for local use only
-      const eventDetail = { functionality, action: TransferEventAction.COMMIT }
+      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorSourceNotMatchingTransferFSPs--${actionLetter}2`))
+
+      // Lets set a default non-matching error to fallback-on
+      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()) {
+        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()) {
+        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)
+
+      // Overriding global boolean declaration with a string value for local as we should handle notifications only to FSPs involved with this transfer
+      const toPayerDestination = transfer.payerFsp
+      const toPayeeDestination = transfer.payeeFsp
+
+      // 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 }
+
+      // Lets handle the abort validation and change the transfer state to reflect this
+      const transferAbortResult = await TransferService.handlePayeeResponse(transferId, payload, TransferEventAction.ABORT_VALIDATION, apiFSPIOPError)
+
       /**
        * TODO: BULK-Handle at BulkProcessingHandler (not in scope of #967)
        * HOWTO: For regular transfers, send the fulfil from non-payee dfsp.
        * Not sure if it will apply to bulk, as it could/should be captured
        * at BulkPrepareHander. To be verified as part of future story.
        */
-      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch, toDestination })
-      throw fspiopError
+
+      // Publish message to Position Handler
+      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: apiFSPIOPError, eventDetail, fromSwitch, toDestination: toPayerDestination })
+
+      /**
+       * Send patch notification callback to original payee fsp if they asked for a a patch response.
+       */
+      if (action === TransferEventAction.RESERVE) {
+        Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackReservedAborted--${actionLetter}3`))
+
+        // Set the event details to map to an RESERVE_ABORTED event targeted to the Notification Handler
+        const reserveAbortedEventDetail = { 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: reserveAbortedEventDetail, toDestination: toPayeeDestination, fromSwitch: true })
+      }
+
+      throw apiFSPIOPError
     }
     // If execution continues after this point we are sure transfer exists and source matches payee fsp
 
-    Logger.info(Util.breadcrumb(location, { path: 'dupCheck' }))
+    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)
@@ -323,29 +427,34 @@ const fulfil = async (error, messages) => {
       dupCheckResult = await Comparators.duplicateCheckComparator(transferId, payload, TransferService.getTransferErrorDuplicateCheck, TransferService.saveTransferErrorDuplicateCheck)
     }
     const { hasDuplicateId, hasDuplicateHash } = dupCheckResult
-
+    histTimerDuplicateCheckEnd({ success: true, funcName: 'fulfil_duplicateCheckComparator' })
     if (hasDuplicateId && hasDuplicateHash) {
-      Logger.info(Util.breadcrumb(location, 'handleResend'))
+      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 recieved a GET /transfers/{ID} from the client
       if (transferStateEnum === TransferState.COMMITTED || transferStateEnum === TransferState.ABORTED) {
         message.value.content.payload = TransferObjectTransform.toFulfil(transfer)
-        if (!isTransferError) {
-          Logger.info(Util.breadcrumb(location, `callbackFinilized2--${actionLetter}3`))
-          const eventDetail = { functionality, action: TransferEventAction.FULFIL_DUPLICATE }
-          /**
-           * HOWTO: During bulk fulfil use an individualTransfer from a previous bulk fulfil
-           */
-          await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail, fromSwitch })
-          histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
-          return true
-        } else {
-          Logger.info(Util.breadcrumb(location, `callbackFinilized3--${actionLetter}4`))
-          const eventDetail = { functionality, 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
+        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
+          }
         }
-      } else if (transferStateEnum === TransferState.RECEIVED || transferStateEnum === TransferState.RESERVED) {
-        Logger.info(Util.breadcrumb(location, `inProgress2--${actionLetter}5`))
+        await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail, fromSwitch })
+        histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
+        return true
+      }
+
+      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
@@ -356,122 +465,228 @@ const fulfil = async (error, messages) => {
         await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, histTimerEnd })
         histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
         return true
-      } else {
-        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 })
-        histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
-        return true
       }
-    } else if (hasDuplicateId && !hasDuplicateHash) {
-      let eventDetail
+
+      // 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 })
+      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)
-      if (!isTransferError) {
-        Logger.info(Util.breadcrumb(location, `callbackErrorModified2--${actionLetter}7`))
-        eventDetail = { functionality, action: TransferEventAction.FULFIL_DUPLICATE }
-        /**
-         * HOWTO: During bulk fulfil use an individualTransfer from a previous bulk fulfil,
-         * but use different fulfilment value.
-         */
-      } else {
-        Logger.info(Util.breadcrumb(location, `callbackErrorModified3--${actionLetter}8`))
-        eventDetail = { functionality, action: TransferEventAction.ABORT_DUPLICATE }
+      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackErrorModified2--${actionLetter}7`))
+      let action = TransferEventAction.FULFIL_DUPLICATE
+      if (isTransferError) {
+        action = TransferEventAction.ABORT_DUPLICATE
       }
+
+      /**
+       * 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 })
       throw fspiopError
-    } else { // !hasDuplicateId
-      if (type === TransferEventType.FULFIL && [TransferEventAction.COMMIT, TransferEventAction.REJECT, TransferEventAction.ABORT, TransferEventAction.BULK_COMMIT].includes(action)) {
-        Util.breadcrumb(location, { path: 'validationFailed' })
-        if (payload.fulfilment && !Validator.validateFulfilCondition(payload.fulfilment, transfer.condition)) {
-          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 }
-          /**
-           * TODO: BulkProcessingHandler (not in scope of #967) The individual transfer is ABORTED by notification is never sent.
-           */
-          await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: apiFspiopError, eventDetail, toDestination })
-          throw fspiopError
-        } else if (transfer.transferState !== TransferState.RESERVED) {
-          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 })
-          throw fspiopError
-        } else if (transfer.expirationDate <= new Date(Util.Time.getUTCString(new Date()))) {
-          Logger.info(Util.breadcrumb(location, `callbackErrorTransferExpired--${actionLetter}11`))
-          const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.TRANSFER_EXPIRED)
-          const eventDetail = { functionality, action: TransferEventAction.COMMIT }
+    }
+
+    // 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 })
+      throw fspiopError
+    }
+
+    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
+    }
+
+    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.
+       */
+      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: apiFSPIOPError, eventDetail, toDestination })
+
+      // 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, toDestination: transfer.payeeFsp, fromSwitch: true })
+      }
+      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 })
+
+      // 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, toDestination: transfer.payeeFsp, fromSwitch: true })
+      }
+      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 })
+
+      // 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
+        }
+        message.value.content.payload = reservedAbortedPayload
+        await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail, toDestination: transfer.payeeFsp, fromSwitch: true })
+      }
+      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)
+        const eventDetail = { functionality: TransferEventType.POSITION, action }
+        await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail, toDestination })
+        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: BulkProcessingHandler (not in scope of #967)
+           * 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.
            */
-          await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch })
+          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 }
+          await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, toDestination })
           throw fspiopError
-        } else { // validations success
-          Logger.info(Util.breadcrumb(location, { path: 'validationPassed' }))
-          if ([TransferEventAction.COMMIT, TransferEventAction.BULK_COMMIT].includes(action)) {
-            Logger.info(Util.breadcrumb(location, `positionTopic2--${actionLetter}12`))
-            await TransferService.handlePayeeResponse(transferId, payload, action)
-            const eventDetail = { functionality: TransferEventType.POSITION, action }
-            await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail, toDestination })
-            histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
-            return true
-          } else {
-            if (action === TransferEventAction.REJECT) {
-              Logger.info(Util.breadcrumb(location, `positionTopic3--${actionLetter}13`))
-              await TransferService.handlePayeeResponse(transferId, payload, action)
-              const eventDetail = { functionality: TransferEventType.POSITION, action: TransferEventAction.REJECT }
-              await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail, toDestination })
-              histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
-              return true
-            } else { // action === TransferEventAction.ABORT // error-callback request to be processed
-              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.
-                 */
-                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: TransferEventAction.ABORT }
-                await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, toDestination })
-                throw fspiopError
-              }
-              await TransferService.handlePayeeResponse(transferId, payload, action, fspiopError.toApiErrorObject(Config.ERROR_HANDLING))
-              const eventDetail = { functionality: TransferEventType.POSITION, action: TransferEventAction.ABORT }
-              await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, toDestination })
-              throw fspiopError
-            }
-          }
         }
-      } else {
-        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 })
+        await TransferService.handlePayeeResponse(transferId, payload, action, fspiopError.toApiErrorObject(Config.ERROR_HANDLING))
+        const eventDetail = { functionality: TransferEventType.POSITION, action }
+        await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, toDestination })
+        // 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
       }
     }
   } catch (err) {
     histTimerEnd({ success: false, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
     const fspiopError = ErrorHandler.Factory.reformatFSPIOPError(err)
-    Logger.error(`${Util.breadcrumb(location)}::${err.message}--F0`)
+    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)
@@ -516,7 +731,7 @@ const getTransfer = async (error, messages) => {
     const action = metadata.event.action
     const transferId = message.value.content.uriParams.id
     const kafkaTopic = message.topic
-    Logger.info(Util.breadcrumb(location, { method: `getTransfer:${action}` }))
+    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 }
@@ -524,27 +739,34 @@ const getTransfer = async (error, messages) => {
 
     Util.breadcrumb(location, { path: 'validationFailed' })
     if (!await Validator.validateParticipantByName(message.value.from)) {
-      Logger.info(Util.breadcrumb(location, `breakParticipantDoesntExist--${actionLetter}1`))
+      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `breakParticipantDoesntExist--${actionLetter}1`))
       await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, histTimerEnd })
       histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
       return true
     }
     const transfer = await TransferService.getByIdLight(transferId)
     if (!transfer) {
-      Logger.info(Util.breadcrumb(location, `callbackErrorTransferNotFound--${actionLetter}3`))
+      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.info(Util.breadcrumb(location, `callbackErrorNotTransferParticipant--${actionLetter}2`))
+      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 (transfer.transferState === Enum.Transfers.TransferInternalState.EXPIRED_RESERVED) {
+      Logger.isInfoEnabled && Logger.info(Util.breadcrumb(location, `callbackTransferExpired--${actionLetter}3`))
+      const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.TRANSFER_EXPIRED)
+      await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch })
+      throw fspiopError
+    }
+
     // ============================================================================================
     Util.breadcrumb(location, { path: 'validationPassed' })
-    Logger.info(Util.breadcrumb(location, `callbackMessage--${actionLetter}4`))
+    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 })
     histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
@@ -552,7 +774,7 @@ const getTransfer = async (error, messages) => {
   } catch (err) {
     histTimerEnd({ success: false, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
     const fspiopError = ErrorHandler.Factory.reformatFSPIOPError(err)
-    Logger.error(`${Util.breadcrumb(location)}::${err.message}--G0`)
+    Logger.isErrorEnabled && Logger.error(`${Util.breadcrumb(location)}::${err.message}--G0`)
     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)
@@ -583,6 +805,7 @@ const registerPrepareHandler = async () => {
     await Consumer.createHandler(prepareHandler.topicName, prepareHandler.config, prepareHandler.command)
     return true
   } catch (err) {
+    Logger.isErrorEnabled && Logger.error(err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -606,6 +829,7 @@ const registerFulfilHandler = async () => {
     await Consumer.createHandler(fulfillHandler.topicName, fulfillHandler.config, fulfillHandler.command)
     return true
   } catch (err) {
+    Logger.isErrorEnabled && Logger.error(err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -629,6 +853,7 @@ const registerGetTransferHandler = async () => {
     await Consumer.createHandler(getHandler.topicName, getHandler.config, getHandler.command)
     return true
   } catch (err) {
+    Logger.isErrorEnabled && Logger.error(err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -648,6 +873,7 @@ const registerAllHandlers = async () => {
     await registerGetTransferHandler()
     return true
   } catch (err) {
+    Logger.isErrorEnabled && Logger.error(err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }