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

package/test/unit/handlers/transfers/handler.test.js

@@ -39,6 +39,7 @@ const Validator = require('../../../../src/handlers/transfers/validator')
 const TransferService = require('../../../../src/domain/transfer')
 const TransferObjectTransform = require('../../../../src/domain/transfer/transform')
 const MainUtil = require('@mojaloop/central-services-shared').Util
+const Time = require('@mojaloop/central-services-shared').Util.Time
 const ilp = require('../../../../src/models/transfer/ilpPacket')
 const Uuid = require('uuid4')
 const KafkaConsumer = require('@mojaloop/central-services-stream').Kafka.Consumer
@@ -49,6 +50,7 @@ const TransferState = Enum.Transfers.TransferState
 const TransferInternalState = Enum.Transfers.TransferInternalState
 const Comparators = require('@mojaloop/central-services-shared').Util.Comparators
 const Proxyquire = require('proxyquire')
+const { getMessagePayloadOrThrow } = require('../../../util/helpers')
 
 const transfer = {
   transferId: 'b51ec534-ee48-4575-b6a9-ead2955b8999',
@@ -131,7 +133,7 @@ const messageProtocol = {
   to: transfer.payeeFsp,
   type: 'application/json',
   content: {
-    headers: { 'fspiop-destination': transfer.payerFsp },
+    headers: { 'fspiop-destination': transfer.payerFsp, 'content-type': 'application/vnd.interoperability.transfers+json;version=1.1' },
     uriParams: { id: transfer.transferId },
     payload: transfer
   },
@@ -177,7 +179,8 @@ const fulfilMessages = [
         uriParams: { id: messageProtocol.content.uriParams.id },
         headers: {
           'fspiop-source': 'dfsp1',
-          'fspiop-destination': 'dfsp2'
+          'fspiop-destination': 'dfsp2',
+          'content-type': 'application/vnd.interoperability.transfers+json;version=1.1'
         }
       },
       metadata: {
@@ -196,7 +199,8 @@ const fulfilMessages = [
         uriParams: { id: messageProtocolBulkCommit.content.uriParams.id },
         headers: {
           'fspiop-source': 'dfsp1',
-          'fspiop-destination': 'dfsp2'
+          'fspiop-destination': 'dfsp2',
+          'content-type': 'application/vnd.interoperability.transfers+json;version=1.1'
         }
       },
       metadata: {
@@ -327,7 +331,7 @@ Test('Transfer handler', transferHandlerTest => {
       await Consumer.createHandler(topicName, config, command)
       Kafka.transformAccountToTopicName.returns(topicName)
       Kafka.proceed.returns(true)
-      Validator.validateByName.returns({ validationPassed: true, reasons: [] })
+      Validator.validatePrepare.returns({ validationPassed: true, reasons: [] })
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
       TransferService.saveTransferDuplicateCheck.returns(Promise.resolve(null))
       Comparators.duplicateCheckComparator.withArgs(transfer.transferId, transfer).returns(Promise.resolve({
@@ -344,7 +348,7 @@ Test('Transfer handler', transferHandlerTest => {
       await Consumer.createHandler(topicName, config, command)
       Consumer.getConsumer.throws(new Error())
       Kafka.transformAccountToTopicName.returns(topicName)
-      Validator.validateByName.returns({ validationPassed: true, reasons: [] })
+      Validator.validatePrepare.returns({ validationPassed: true, reasons: [] })
       TransferService.prepare.returns(Promise.resolve(true))
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
       TransferService.saveTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -362,7 +366,7 @@ Test('Transfer handler', transferHandlerTest => {
       await Consumer.createHandler(topicName, config, command)
       Kafka.transformAccountToTopicName.returns(topicName)
       Kafka.proceed.returns(true)
-      Validator.validateByName.returns({ validationPassed: true, reasons: [] })
+      Validator.validatePrepare.returns({ validationPassed: true, reasons: [] })
       TransferService.getByIdLight.returns(Promise.resolve(null))
       TransferService.prepare.returns(Promise.resolve(true))
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -383,7 +387,7 @@ Test('Transfer handler', transferHandlerTest => {
       Consumer.isConsumerAutoCommitEnabled.returns(true)
       Kafka.transformAccountToTopicName.returns(topicName)
       Kafka.proceed.returns(true)
-      Validator.validateByName.returns({ validationPassed: true, reasons: [] })
+      Validator.validatePrepare.returns({ validationPassed: true, reasons: [] })
       TransferService.getByIdLight.returns(Promise.resolve(null))
       TransferService.prepare.returns(Promise.resolve(true))
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -403,7 +407,7 @@ Test('Transfer handler', transferHandlerTest => {
       await Consumer.createHandler(topicName, configAutocommit, command)
       Kafka.transformAccountToTopicName.returns(topicName)
       Kafka.proceed.returns(true)
-      Validator.validateByName.returns({ validationPassed: true, reasons: [] })
+      Validator.validatePrepare.returns({ validationPassed: true, reasons: [] })
       TransferService.getByIdLight.returns(Promise.resolve(null))
       TransferService.prepare.returns(Promise.resolve(true))
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -423,7 +427,7 @@ Test('Transfer handler', transferHandlerTest => {
       await Consumer.createHandler(topicName, config, command)
       Kafka.transformAccountToTopicName.returns(topicName)
       Kafka.proceed.returns(true)
-      Validator.validateByName.returns({ validationPassed: true, reasons: [] })
+      Validator.validatePrepare.returns({ validationPassed: true, reasons: [] })
       TransferService.prepare.returns(Promise.resolve(true))
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
       TransferService.saveTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -444,7 +448,7 @@ Test('Transfer handler', transferHandlerTest => {
       await Consumer.createHandler(topicName, config, command)
       Kafka.transformAccountToTopicName.returns(topicName)
       Kafka.proceed.returns(true)
-      Validator.validateByName.returns({ validationPassed: true, reasons: [] })
+      Validator.validatePrepare.returns({ validationPassed: true, reasons: [] })
       TransferService.prepare.returns(Promise.resolve(true))
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
       TransferService.saveTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -467,7 +471,7 @@ Test('Transfer handler', transferHandlerTest => {
       await Consumer.createHandler(topicName, config, command)
       Kafka.transformAccountToTopicName.returns(topicName)
       Kafka.proceed.returns(true)
-      Validator.validateByName.returns({ validationPassed: true, reasons: [] })
+      Validator.validatePrepare.returns({ validationPassed: true, reasons: [] })
       TransferService.prepare.returns(Promise.resolve(true))
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
       TransferService.saveTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -487,7 +491,7 @@ Test('Transfer handler', transferHandlerTest => {
       await Consumer.createHandler(topicName, config, command)
       Kafka.transformAccountToTopicName.returns(topicName)
       Kafka.proceed.returns(true)
-      Validator.validateByName.returns({ validationPassed: true, reasons: [] })
+      Validator.validatePrepare.returns({ validationPassed: true, reasons: [] })
       TransferService.prepare.returns(Promise.resolve(true))
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
       TransferService.saveTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -508,7 +512,7 @@ Test('Transfer handler', transferHandlerTest => {
       await Consumer.createHandler(topicName, config, command)
       Kafka.transformAccountToTopicName.returns(topicName)
       Kafka.proceed.returns(true)
-      Validator.validateByName.returns({ validationPassed: true, reasons: [] })
+      Validator.validatePrepare.returns({ validationPassed: true, reasons: [] })
       TransferService.prepare.returns(Promise.resolve(true))
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
       TransferService.saveTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -528,7 +532,7 @@ Test('Transfer handler', transferHandlerTest => {
       await Consumer.createHandler(topicName, config, command)
       Kafka.transformAccountToTopicName.returns(topicName)
       Kafka.proceed.returns(true)
-      Validator.validateByName.returns({ validationPassed: true, reasons: [] })
+      Validator.validatePrepare.returns({ validationPassed: true, reasons: [] })
       TransferService.prepare.returns(Promise.resolve(true))
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
       TransferService.saveTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -548,7 +552,7 @@ Test('Transfer handler', transferHandlerTest => {
       Consumer.isConsumerAutoCommitEnabled.returns(true)
       Kafka.transformAccountToTopicName.returns(topicName)
       Kafka.proceed.returns(true)
-      Validator.validateByName.returns({ validationPassed: true, reasons: [] })
+      Validator.validatePrepare.returns({ validationPassed: true, reasons: [] })
       TransferService.prepare.returns(Promise.resolve(true))
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
       TransferService.saveTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -567,7 +571,7 @@ Test('Transfer handler', transferHandlerTest => {
       await Consumer.createHandler(topicName, config, command)
       Kafka.transformAccountToTopicName.returns(topicName)
       Kafka.proceed.returns(true)
-      Validator.validateByName.returns({ validationPassed: true, reasons: [] })
+      Validator.validatePrepare.returns({ validationPassed: true, reasons: [] })
       TransferService.prepare.returns(Promise.resolve(true))
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
       TransferService.saveTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -585,7 +589,7 @@ Test('Transfer handler', transferHandlerTest => {
       await Consumer.createHandler(topicName, config, command)
       Kafka.transformAccountToTopicName.returns(topicName)
       Kafka.proceed.returns(true)
-      Validator.validateByName.returns({ validationPassed: true, reasons: [] })
+      Validator.validatePrepare.returns({ validationPassed: true, reasons: [] })
       TransferService.prepare.returns(Promise.resolve(true))
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
       TransferService.saveTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -604,7 +608,7 @@ Test('Transfer handler', transferHandlerTest => {
       Consumer.isConsumerAutoCommitEnabled.returns(true)
       Kafka.transformAccountToTopicName.returns(topicName)
       Kafka.proceed.returns(true)
-      Validator.validateByName.returns({ validationPassed: true, reasons: [] })
+      Validator.validatePrepare.returns({ validationPassed: true, reasons: [] })
       TransferService.prepare.returns(Promise.resolve(true))
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
       TransferService.saveTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -622,7 +626,7 @@ Test('Transfer handler', transferHandlerTest => {
       await Consumer.createHandler(topicName, configAutocommit, command)
       Kafka.transformAccountToTopicName.returns(topicName)
       Kafka.proceed.returns(true)
-      Validator.validateByName.returns({ validationPassed: true, reasons: [] })
+      Validator.validatePrepare.returns({ validationPassed: true, reasons: [] })
       TransferService.prepare.returns(Promise.resolve(true))
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
       TransferService.saveTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -640,7 +644,7 @@ Test('Transfer handler', transferHandlerTest => {
       await Consumer.createHandler(topicName, config, command)
       Kafka.transformAccountToTopicName.returns(topicName)
       Kafka.proceed.returns(true)
-      Validator.validateByName.returns({ validationPassed: true, reasons: [] })
+      Validator.validatePrepare.returns({ validationPassed: true, reasons: [] })
       TransferService.prepare.throws(new Error())
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
       TransferService.saveTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -659,7 +663,7 @@ Test('Transfer handler', transferHandlerTest => {
       Consumer.isConsumerAutoCommitEnabled.returns(true)
       Kafka.transformAccountToTopicName.returns(topicName)
       Kafka.proceed.returns(true)
-      Validator.validateByName.returns({ validationPassed: true, reasons: [] })
+      Validator.validatePrepare.returns({ validationPassed: true, reasons: [] })
       TransferService.prepare.throws(new Error())
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
       TransferService.saveTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -684,7 +688,7 @@ Test('Transfer handler', transferHandlerTest => {
         hasDuplicateHash: false
       }))
       MainUtil.StreamingProtocol.createEventState.returns(messageProtocol.metadata.event.state)
-      Validator.validateByName.returns({ validationPassed: false, reasons: [] })
+      Validator.validatePrepare.returns({ validationPassed: false, reasons: [] })
       TransferService.getById.returns(Promise.resolve(null))
       TransferService.prepare.returns(Promise.resolve(true))
       const result = await allTransferHandlers.prepare(null, localMessages)
@@ -704,7 +708,7 @@ Test('Transfer handler', transferHandlerTest => {
         hasDuplicateHash: false
       }))
       MainUtil.StreamingProtocol.createEventState.returns(messageProtocol.metadata.event.state)
-      Validator.validateByName.returns({ validationPassed: false, reasons: [] })
+      Validator.validatePrepare.returns({ validationPassed: false, reasons: [] })
       TransferService.prepare.returns(Promise.resolve(true))
 
       const result = await allTransferHandlers.prepare(null, messages)
@@ -717,7 +721,7 @@ Test('Transfer handler', transferHandlerTest => {
       await Consumer.createHandler(topicName, config, command)
       Kafka.transformAccountToTopicName.returns(topicName)
       Kafka.proceed.returns(true)
-      Validator.validateByName.returns({ validationPassed: false, reasons: [] })
+      Validator.validatePrepare.returns({ validationPassed: false, reasons: [] })
       TransferService.prepare.throws(new Error())
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
       TransferService.saveTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -736,7 +740,7 @@ Test('Transfer handler', transferHandlerTest => {
       Consumer.isConsumerAutoCommitEnabled.returns(true)
       Kafka.transformAccountToTopicName.returns(topicName)
       Kafka.proceed.returns(true)
-      Validator.validateByName.returns({ validationPassed: false, reasons: [] })
+      Validator.validatePrepare.returns({ validationPassed: false, reasons: [] })
       TransferService.prepare.throws(new Error())
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
       TransferService.saveTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -931,6 +935,28 @@ Test('Transfer handler', transferHandlerTest => {
       test.end()
     })
 
+    transformTransfer.test('log an error when the transfer state is EXPIRED_RESERVED', async (test) => {
+      const localMessages = MainUtil.clone(messages)
+      await Consumer.createHandler(topicName, config, command)
+      Kafka.proceed.returns(Promise.resolve(true))
+      Validator.validateParticipantByName.returns(true)
+      Validator.validateParticipantTransferId.returns(true)
+      const transferResult = MainUtil.clone(transferReturn)
+      transferResult.transferState = 'EXPIRED_RESERVED'
+      transferResult.extensionList = []
+      TransferService.getByIdLight.withArgs(transfer.transferId).returns(Promise.resolve(transferResult))
+
+      try {
+        await allTransferHandlers.getTransfer(null, localMessages)
+        const expectedState = new EventSdk.EventStateMetadata(EventSdk.EventStatusType.failed, '3303', 'Transfer expired')
+        test.ok(SpanStub.finish.calledWith('', expectedState))
+        test.end()
+      } catch (e) {
+        test.fail('Error thrown')
+        test.end()
+      }
+    })
+
     transformTransfer.test('log an error when general message cannot be produced', async (test) => {
       const localMessages = MainUtil.clone(messages)
       await Consumer.createHandler(topicName, config, command)
@@ -957,6 +983,137 @@ Test('Transfer handler', transferHandlerTest => {
   })
 
   transferHandlerTest.test('fulfil should', fulfilTest => {
+    fulfilTest.test('emit a RESERVED_ABORTED if validation fails when transfer.expirationDate has passed', async (test) => {
+      // Arrange
+      const localfulfilMessages = MainUtil.clone(fulfilMessages)
+      localfulfilMessages[0].value.content.payload.transferState = 'RESERVED'
+      localfulfilMessages[0].value.metadata.event.action = 'reserve'
+
+      // mock out validation calls
+      TransferService.getById.returns(Promise.resolve({
+        condition: 'condition',
+        payeeFsp: 'dfsp1',
+        payerFsp: 'dfsp2',
+        transferState: TransferState.RESERVED,
+        id: Uuid(),
+        completedTimestamp: Time.getUTCString(new Date()),
+        expirationDate: new Date('2020-01-01')
+      }))
+      Comparators.duplicateCheckComparator.withArgs(
+        transfer.transferId,
+        localfulfilMessages[0].value.content.payload
+      ).returns(Promise.resolve({
+        hasDuplicateId: false,
+        hasDuplicateHash: false
+      }))
+      Validator.validateFulfilCondition.returns(true)
+      Kafka.proceed.returns(true)
+
+      // Act
+      const result = await allTransferHandlers.fulfil(null, localfulfilMessages)
+
+      // Assert
+      test.ok(Kafka.proceed.calledTwice, 'Kafka.proceed was called twice')
+      const reservedAbortedPayload = getMessagePayloadOrThrow(Kafka.proceed.getCall(1).args[1].message)
+      test.equal(reservedAbortedPayload.transferState, 'ABORTED')
+      test.ok(reservedAbortedPayload.transferId, 'payload.transferId is defined')
+      test.ok(reservedAbortedPayload.completedTimestamp, 'payload.completedTimestamp is defined')
+      test.equal(result, true)
+      test.end()
+    })
+
+    fulfilTest.test('emit a RESERVED_ABORTED if validation fails when transferState !== RESERVED', async (test) => {
+      // Arrange
+      const localfulfilMessages = MainUtil.clone(fulfilMessages)
+      localfulfilMessages[0].value.content.payload.transferState = 'RESERVED'
+      localfulfilMessages[0].value.metadata.event.action = 'reserve'
+
+      // mock out validation calls
+      TransferService.getById.returns(Promise.resolve({
+        condition: 'condition',
+        payeeFsp: 'dfsp1',
+        payerFsp: 'dfsp2',
+        transferState: TransferState.ABORTED,
+        id: Uuid(),
+        completedTimestamp: Time.getUTCString(new Date())
+
+      }))
+      Comparators.duplicateCheckComparator.withArgs(
+        transfer.transferId,
+        localfulfilMessages[0].value.content.payload
+      ).returns(Promise.resolve({
+        hasDuplicateId: false,
+        hasDuplicateHash: false
+      }))
+      Validator.validateFulfilCondition.returns(true)
+      Kafka.proceed.returns(true)
+
+      // Act
+      const result = await allTransferHandlers.fulfil(null, localfulfilMessages)
+
+      // Assert
+      test.ok(Kafka.proceed.calledTwice, 'Kafka.proceed was called twice')
+      const reservedAbortedPayload = getMessagePayloadOrThrow(Kafka.proceed.getCall(1).args[1].message)
+      test.equal(reservedAbortedPayload.transferState, 'ABORTED')
+      test.ok(reservedAbortedPayload.transferId, 'payload.transferId is defined')
+      test.ok(reservedAbortedPayload.completedTimestamp, 'payload.completedTimestamp is defined')
+      test.equal(result, true)
+      test.end()
+    })
+
+    fulfilTest.test('emit a RESERVED_ABORTED if validation fails when action === RESERVE', async (test) => {
+      // Arrange
+      const localfulfilMessages = MainUtil.clone(fulfilMessages)
+      localfulfilMessages[0].value.content.payload.transferState = 'RESERVED'
+      localfulfilMessages[0].value.metadata.event.action = 'reserve'
+
+      // mock out validation calls
+      TransferService.getById.returns(Promise.resolve({
+        condition: 'condition',
+        payeeFsp: 'dfsp1',
+        payerFsp: 'dfsp2',
+        transferState: TransferState.RESERVED,
+        id: Uuid(),
+        completedTimestamp: Time.getUTCString(new Date())
+
+      }))
+      Comparators.duplicateCheckComparator.withArgs(
+        transfer.transferId,
+        localfulfilMessages[0].value.content.payload
+      ).returns(Promise.resolve({
+        hasDuplicateId: false,
+        hasDuplicateHash: false
+      }))
+      Validator.validateFulfilCondition.returns(false)
+      Kafka.proceed.returns(true)
+
+      // Act
+      const result = await allTransferHandlers.fulfil(null, localfulfilMessages)
+
+      // Assert
+      test.ok(Kafka.proceed.calledTwice, 'Kafka.proceed was called twice')
+      const reservedAbortedPayload = getMessagePayloadOrThrow(Kafka.proceed.getCall(1).args[1].message)
+      test.equal(reservedAbortedPayload.transferState, 'ABORTED')
+      test.ok(reservedAbortedPayload.transferId, 'payload.transferId is defined')
+      test.ok(reservedAbortedPayload.completedTimestamp, 'payload.completedTimestamp is defined')
+      test.equal(result, true)
+      test.end()
+    })
+
+    fulfilTest.test('fail validation when when RESERVED transfer state is received from v1.0 clients', async (test) => {
+      const localfulfilMessages = MainUtil.clone(fulfilMessages)
+      localfulfilMessages[0].value.content.headers['content-type'] = 'application/vnd.interoperability.transfers+json;version=1.0'
+      localfulfilMessages[0].value.content.payload.transferState = 'RESERVED'
+      await Consumer.createHandler(topicName, config, command)
+      Kafka.transformGeneralTopicName.returns(topicName)
+      TransferService.getById.returns(Promise.resolve(null))
+      Kafka.proceed.returns(true)
+
+      const result = await allTransferHandlers.fulfil(null, localfulfilMessages)
+      test.equal(result, true)
+      test.end()
+    })
+
     fulfilTest.test('fail validation when invalid event action is provided', async (test) => {
       const localfulfilMessages = MainUtil.clone(fulfilMessages)
       await Consumer.createHandler(topicName, config, command)
@@ -995,30 +1152,198 @@ Test('Transfer handler', transferHandlerTest => {
       test.end()
     })
 
+    fulfilTest.test('fail validation when fspiop-destination does not match payerFsp', async (test) => {
+      // Setup
+      const localfulfilMessages = MainUtil.clone(fulfilMessages)
+      await Consumer.createHandler(topicName, config, command)
+      Kafka.transformGeneralTopicName.returns(topicName)
+      TransferService.getById.returns(Promise.resolve({
+        payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1'
+      }))
+      localfulfilMessages[0].value.content.headers['fspiop-source'] = 'dfsp2'
+      localfulfilMessages[0].value.content.headers['fspiop-destination'] = 'fspdoesnotexist'
+      Kafka.proceed.returns(true)
+
+      // Act
+      const result = await allTransferHandlers.fulfil(null, localfulfilMessages)
+
+      // Assert
+
+      test.equal(result, true)
+      test.ok(Kafka.proceed.calledOnce, 'Kafka.proceed was called once')
+
+      // fetch kafka proceed arguments
+      const kafkaCallOne = Kafka.proceed.getCall(0)
+
+      // lets check if the first kafka proceed message contains an applicable error
+      test.equal(kafkaCallOne.args[2].fspiopError.errorInformation.errorCode, '3100')
+      test.equal(kafkaCallOne.args[2].fspiopError.errorInformation.errorDescription, 'Generic validation error - fspiop-destination does not match payer fsp on the Fulfil callback response')
+      test.equal(kafkaCallOne.args[2].eventDetail.functionality, Enum.Events.Event.Type.POSITION)
+      test.equal(kafkaCallOne.args[2].eventDetail.action, Enum.Events.Event.Action.ABORT_VALIDATION)
+      test.equal(kafkaCallOne.args[2].fromSwitch, true)
+      test.equal(kafkaCallOne.args[2].toDestination, 'dfsp1')
+
+      test.end()
+    })
+
     fulfilTest.test('fail validation when fspiop-source does not match payeeFsp', async (test) => {
+      // Setup
       const localfulfilMessages = MainUtil.clone(fulfilMessages)
       await Consumer.createHandler(topicName, config, command)
       Kafka.transformGeneralTopicName.returns(topicName)
-      TransferService.getById.returns(Promise.resolve({ payeeFsp: 'dfsp2' }))
-      localfulfilMessages[0].value.content.headers['fspiop-source'] = 'dfsp1'
+      TransferService.getById.returns(Promise.resolve({
+        payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1'
+      }))
+      localfulfilMessages[0].value.content.headers['fspiop-source'] = 'fspdoesnotexist'
+      localfulfilMessages[0].value.content.headers['fspiop-destination'] = 'dfsp1'
       Kafka.proceed.returns(true)
 
+      // Act
       const result = await allTransferHandlers.fulfil(null, localfulfilMessages)
+
+      // Assert
       test.equal(result, true)
+      test.ok(Kafka.proceed.calledOnce, 'Kafka.proceed was called once')
+
+      // fetch kafka proceed arguments
+      const kafkaCallOne = Kafka.proceed.getCall(0)
+
+      // lets check if the first kafka proceed message contains an applicable error
+      test.equal(kafkaCallOne.args[2].fspiopError.errorInformation.errorCode, '3100')
+      test.equal(kafkaCallOne.args[2].fspiopError.errorInformation.errorDescription, 'Generic validation error - fspiop-source does not match payee fsp on the Fulfil callback response')
+      test.equal(kafkaCallOne.args[2].eventDetail.functionality, Enum.Events.Event.Type.POSITION)
+      test.equal(kafkaCallOne.args[2].eventDetail.action, Enum.Events.Event.Action.ABORT_VALIDATION)
+      test.equal(kafkaCallOne.args[2].fromSwitch, true)
+      test.equal(kafkaCallOne.args[2].toDestination, 'dfsp1')
+
       test.end()
     })
 
     fulfilTest.test('fail validation when fspiop-source does not match payeeFsp - autocommit is enabled', async (test) => {
+      // Setup
       const localfulfilMessages = MainUtil.clone(fulfilMessages)
       await Consumer.createHandler(topicName, config, command)
       Consumer.isConsumerAutoCommitEnabled.returns(true)
       Kafka.transformGeneralTopicName.returns(topicName)
-      TransferService.getById.returns(Promise.resolve({ payeeFsp: 'dfsp2' }))
-      localfulfilMessages[0].value.content.headers['fspiop-source'] = 'dfsp1'
+      TransferService.getById.returns(Promise.resolve({
+        payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1'
+      }))
+      localfulfilMessages[0].value.content.headers['fspiop-source'] = 'fspdoesnotexist'
+      localfulfilMessages[0].value.content.headers['fspiop-destination'] = 'dfsp1'
+      Kafka.proceed.returns(true)
+
+      // Act
+      const result = await allTransferHandlers.fulfil(null, localfulfilMessages)
+
+      // Assert
+      test.equal(result, true)
+      test.ok(Kafka.proceed.calledOnce, 'Kafka.proceed was called once')
+
+      // fetch kafka proceed arguments
+      const kafkaCallOne = Kafka.proceed.getCall(0)
+
+      // lets check if the first kafka proceed message contains an applicable error
+      test.equal(kafkaCallOne.args[2].fspiopError.errorInformation.errorCode, '3100')
+      test.equal(kafkaCallOne.args[2].fspiopError.errorInformation.errorDescription, 'Generic validation error - fspiop-source does not match payee fsp on the Fulfil callback response')
+      test.equal(kafkaCallOne.args[2].eventDetail.functionality, Enum.Events.Event.Type.POSITION)
+      test.equal(kafkaCallOne.args[2].eventDetail.action, Enum.Events.Event.Action.ABORT_VALIDATION)
+      test.equal(kafkaCallOne.args[2].fromSwitch, true)
+      test.equal(kafkaCallOne.args[2].toDestination, 'dfsp1')
+
+      test.end()
+    })
+
+    fulfilTest.test('fail validation when fspiop-destination does not match payerFsp for RESERVED callback', async (test) => {
+      // Setup
+      const localfulfilMessages = MainUtil.clone(fulfilMessages)
+      await Consumer.createHandler(topicName, config, command)
+      Kafka.transformGeneralTopicName.returns(topicName)
+      TransferService.getById.returns(Promise.resolve({
+        payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1'
+      }))
+      localfulfilMessages[0].value.content.headers['fspiop-source'] = 'dfsp2'
+      localfulfilMessages[0].value.content.headers['fspiop-destination'] = 'fspdoesnotexist'
+      localfulfilMessages[0].value.content.headers['content-type'] = 'application/vnd.interoperability.transfers+json;version=1.1'
+      localfulfilMessages[0].value.content.payload.transferState = TransferState.RESERVED
+      localfulfilMessages[0].value.metadata.event.action = Enum.Events.Event.Action.RESERVE
+      Kafka.proceed.returns(true)
+
+      // Act
+      const result = await allTransferHandlers.fulfil(null, localfulfilMessages)
+
+      // Assert
+
+      test.equal(result, true)
+      test.ok(Kafka.proceed.calledTwice, 'Kafka.proceed was called twice')
+
+      // fetch kafka proceed arguments
+      const kafkaCallOne = Kafka.proceed.getCall(0)
+      const kafkaCallTwo = Kafka.proceed.getCall(1)
+
+      // lets check if the first kafka proceed message contains an applicable error
+      test.equal(kafkaCallOne.args[2].fspiopError.errorInformation.errorCode, '3100')
+      test.equal(kafkaCallOne.args[2].fspiopError.errorInformation.errorDescription, 'Generic validation error - fspiop-destination does not match payer fsp on the Fulfil callback response')
+      test.equal(kafkaCallOne.args[2].eventDetail.functionality, Enum.Events.Event.Type.POSITION)
+      test.equal(kafkaCallOne.args[2].eventDetail.action, Enum.Events.Event.Action.ABORT_VALIDATION)
+      test.equal(kafkaCallOne.args[2].fromSwitch, true)
+      test.equal(kafkaCallOne.args[2].toDestination, 'dfsp1')
+
+      // lets check if the outbound event is sent to the notifications with the correct status
+      test.equal(kafkaCallTwo.args[1].message.value.content.payload.transferState, TransferState.ABORTED)
+      test.equal(kafkaCallTwo.args[2].eventDetail.functionality, Enum.Events.Event.Type.NOTIFICATION)
+      test.equal(kafkaCallTwo.args[2].eventDetail.action, Enum.Events.Event.Action.RESERVED_ABORTED)
+      test.equal(kafkaCallTwo.args[2].fromSwitch, true)
+      test.equal(kafkaCallTwo.args[2].toDestination, 'dfsp2')
+
+      test.end()
+    })
+
+    fulfilTest.test('fail validation when fspiop-source does not match payeeFsp for RESERVED callback', async (test) => {
+      // Setup
+      const localfulfilMessages = MainUtil.clone(fulfilMessages)
+      await Consumer.createHandler(topicName, config, command)
+      Kafka.transformGeneralTopicName.returns(topicName)
+      TransferService.getById.returns(Promise.resolve({
+        payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1'
+      }))
+      localfulfilMessages[0].value.content.headers['fspiop-source'] = 'fspdoesnotexist'
+      localfulfilMessages[0].value.content.headers['fspiop-destination'] = 'dfsp1'
+      localfulfilMessages[0].value.content.headers['content-type'] = 'application/vnd.interoperability.transfers+json;version=1.1'
+      localfulfilMessages[0].value.content.payload.transferState = TransferState.RESERVED
+      localfulfilMessages[0].value.metadata.event.action = Enum.Events.Event.Action.RESERVE
       Kafka.proceed.returns(true)
 
+      // Act
       const result = await allTransferHandlers.fulfil(null, localfulfilMessages)
+
+      // Assert
       test.equal(result, true)
+      test.ok(Kafka.proceed.calledTwice, 'Kafka.proceed was called twice')
+
+      // fetch kafka proceed arguments
+      const kafkaCallOne = Kafka.proceed.getCall(0)
+      const kafkaCallTwo = Kafka.proceed.getCall(1)
+
+      // lets check if the first kafka proceed message contains an applicable error
+      test.equal(kafkaCallOne.args[2].fspiopError.errorInformation.errorCode, '3100')
+      test.equal(kafkaCallOne.args[2].fspiopError.errorInformation.errorDescription, 'Generic validation error - fspiop-source does not match payee fsp on the Fulfil callback response')
+      test.equal(kafkaCallOne.args[2].eventDetail.functionality, Enum.Events.Event.Type.POSITION)
+      test.equal(kafkaCallOne.args[2].eventDetail.action, Enum.Events.Event.Action.ABORT_VALIDATION)
+      test.equal(kafkaCallOne.args[2].fromSwitch, true)
+      test.equal(kafkaCallOne.args[2].toDestination, 'dfsp1')
+
+      // lets check if the outbound event is sent to the notifications with the correct status
+      test.equal(kafkaCallTwo.args[1].message.value.content.payload.transferState, TransferState.ABORTED)
+      test.equal(kafkaCallTwo.args[2].eventDetail.functionality, Enum.Events.Event.Type.NOTIFICATION)
+      test.equal(kafkaCallTwo.args[2].eventDetail.action, Enum.Events.Event.Action.RESERVED_ABORTED)
+      test.equal(kafkaCallTwo.args[2].fromSwitch, true)
+      test.equal(kafkaCallTwo.args[2].toDestination, 'dfsp2')
+
       test.end()
     })
 
@@ -1026,8 +1351,13 @@ Test('Transfer handler', transferHandlerTest => {
       const localfulfilMessages = MainUtil.clone(fulfilMessages)
       await Consumer.createHandler(topicName, config, command)
       Kafka.transformGeneralTopicName.returns(topicName)
-      TransferService.getById.returns(Promise.resolve({ condition: 'condition', payeeFsp: 'dfsp2' }))
+      TransferService.getById.returns(Promise.resolve({
+        condition: 'condition',
+        payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1'
+      }))
       localfulfilMessages[0].value.content.headers['fspiop-source'] = 'dfsp2'
+      localfulfilMessages[0].value.content.headers['fspiop-destination'] = 'dfsp1'
       localfulfilMessages[0].value.content.payload.fulfilment = 'fulfilment'
       Kafka.proceed.returns(true)
 
@@ -1048,8 +1378,13 @@ Test('Transfer handler', transferHandlerTest => {
       await Consumer.createHandler(topicName, config, command)
       Consumer.isConsumerAutoCommitEnabled.returns(true)
       Kafka.transformGeneralTopicName.returns(topicName)
-      TransferService.getById.returns(Promise.resolve({ condition: 'condition', payeeFsp: 'dfsp2' }))
+      TransferService.getById.returns(Promise.resolve({
+        condition: 'condition',
+        payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1'
+      }))
       localfulfilMessages[0].value.content.headers['fspiop-source'] = 'dfsp2'
+      localfulfilMessages[0].value.content.headers['fspiop-destination'] = 'dfsp1'
       localfulfilMessages[0].value.content.payload.fulfilment = 'fulfilment'
       Kafka.proceed.returns(true)
 
@@ -1069,9 +1404,15 @@ Test('Transfer handler', transferHandlerTest => {
       const localfulfilMessages = MainUtil.clone(fulfilMessages)
       await Consumer.createHandler(topicName, config, command)
       Kafka.transformGeneralTopicName.returns(topicName)
-      TransferService.getById.returns(Promise.resolve({ condition: 'condition', payeeFsp: 'dfsp2', transferState: TransferInternalState.RECEIVED_PREPARE }))
+      TransferService.getById.returns(Promise.resolve({
+        condition: 'condition',
+        payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1',
+        transferState: TransferState.RECEIVED_PREPARE
+      }))
       Validator.validateFulfilCondition.returns(true)
       localfulfilMessages[0].value.content.headers['fspiop-source'] = 'dfsp2'
+      localfulfilMessages[0].value.content.headers['fspiop-destination'] = 'dfsp1'
       localfulfilMessages[0].value.content.payload.fulfilment = 'condition'
       Kafka.proceed.returns(true)
 
@@ -1091,10 +1432,46 @@ Test('Transfer handler', transferHandlerTest => {
       const localfulfilMessages = MainUtil.clone(fulfilMessages)
       await Consumer.createHandler(topicName, config, command)
       Kafka.transformGeneralTopicName.returns(topicName)
-      TransferService.getById.returns(Promise.resolve({ condition: 'condition', payeeFsp: 'dfsp2', transferState: TransferState.RESERVED }))
+      TransferService.getById.returns(Promise.resolve({
+        condition: 'condition',
+        payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1',
+        transferState: TransferState.RESERVED
+      }))
       ilp.update.returns(Promise.resolve())
       Validator.validateFulfilCondition.returns(true)
       localfulfilMessages[0].value.content.headers['fspiop-source'] = 'dfsp2'
+      localfulfilMessages[0].value.content.headers['fspiop-destination'] = 'dfsp1'
+      localfulfilMessages[0].value.content.payload.fulfilment = 'condition'
+      Kafka.proceed.returns(true)
+
+      TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
+      TransferService.saveTransferDuplicateCheck.returns(Promise.resolve(null))
+      Comparators.duplicateCheckComparator.withArgs(transfer.transferId, localfulfilMessages[0].value.content.payload).returns(Promise.resolve({
+        hasDuplicateId: false,
+        hasDuplicateHash: false
+      }))
+
+      const result = await allTransferHandlers.fulfil(null, localfulfilMessages)
+      test.equal(result, true)
+      test.end()
+    })
+
+    fulfilTest.test('produce message to position topic when validations pass and action is RESERVE', async (test) => {
+      const localfulfilMessages = MainUtil.clone(fulfilMessages)
+      localfulfilMessages[0].value.metadata.event.action = 'reserve'
+      await Consumer.createHandler(topicName, config, command)
+      Kafka.transformGeneralTopicName.returns(topicName)
+      TransferService.getById.returns(Promise.resolve({
+        condition: 'condition',
+        payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1',
+        transferState: TransferState.RESERVED
+      }))
+      ilp.update.returns(Promise.resolve())
+      Validator.validateFulfilCondition.returns(true)
+      localfulfilMessages[0].value.content.headers['fspiop-source'] = 'dfsp2'
+      localfulfilMessages[0].value.content.headers['fspiop-destination'] = 'dfsp1'
       localfulfilMessages[0].value.content.payload.fulfilment = 'condition'
       Kafka.proceed.returns(true)
 
@@ -1114,10 +1491,16 @@ Test('Transfer handler', transferHandlerTest => {
       const localfulfilMessages = MainUtil.clone(fulfilMessages)
       await Consumer.createHandler(topicName, config, command)
       Kafka.transformGeneralTopicName.returns(topicName)
-      TransferService.getById.returns(Promise.resolve({ condition: 'condition', payeeFsp: 'dfsp2', transferState: TransferState.RESERVED }))
+      TransferService.getById.returns(Promise.resolve({
+        condition: 'condition',
+        payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1',
+        transferState: TransferState.RESERVED
+      }))
       ilp.update.returns(Promise.resolve())
       Validator.validateFulfilCondition.returns(true)
       localfulfilMessages[1].value.content.headers['fspiop-source'] = 'dfsp2'
+      localfulfilMessages[1].value.content.headers['fspiop-destination'] = 'dfsp1'
       localfulfilMessages[1].value.content.payload.fulfilment = 'condition'
       Kafka.proceed.returns(true)
 
@@ -1133,16 +1516,52 @@ Test('Transfer handler', transferHandlerTest => {
       test.end()
     })
 
+    fulfilTest.test('produce message to position topic when BULK_ABORT message is received', async (test) => {
+      const localfulfilMessages = MainUtil.clone(fulfilMessages)
+      await Consumer.createHandler(topicName, config, command)
+      Kafka.transformGeneralTopicName.returns(topicName)
+      TransferService.getById.returns(Promise.resolve({
+        condition: 'condition',
+        payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1',
+        transferState: TransferState.RESERVED
+      }))
+      ilp.update.returns(Promise.resolve())
+      Validator.validateFulfilCondition.returns(true)
+      localfulfilMessages[1].value.content.headers['fspiop-source'] = 'dfsp2'
+      localfulfilMessages[1].value.content.headers['fspiop-destination'] = 'dfsp1'
+      localfulfilMessages[1].value.content.payload = errInfo
+      localfulfilMessages[1].value.metadata.event.action = 'bulk-abort'
+      Kafka.proceed.returns(true)
+
+      TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
+      TransferService.saveTransferDuplicateCheck.returns(Promise.resolve(null))
+      Comparators.duplicateCheckComparator.withArgs(transfer.transferId, localfulfilMessages[1].value.content.payload).returns(Promise.resolve({
+        hasDuplicateId: false,
+        hasDuplicateHash: false
+      }))
+
+      const result = await allTransferHandlers.fulfil(null, localfulfilMessages[1])
+      test.equal(result, true)
+      test.end()
+    })
+
     fulfilTest.test('produce message to position topic when validations pass - autocommit is enabled', async (test) => {
       const localfulfilMessages = MainUtil.clone(fulfilMessages)
       await Consumer.createHandler(topicName, config, command)
       Consumer.isConsumerAutoCommitEnabled.returns(true)
       Validator.validateFulfilCondition.returns(true)
       Kafka.transformGeneralTopicName.returns(topicName)
-      TransferService.getById.returns(Promise.resolve({ condition: 'condition', payeeFsp: 'dfsp2', transferState: TransferState.RESERVED }))
+      TransferService.getById.returns(Promise.resolve({
+        condition: 'condition',
+        payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1',
+        transferState: TransferState.RESERVED
+      }))
       ilp.update.returns(Promise.resolve())
       Kafka.proceed.returns(true)
       localfulfilMessages[0].value.content.headers['fspiop-source'] = 'dfsp2'
+      localfulfilMessages[0].value.content.headers['fspiop-destination'] = 'dfsp1'
       localfulfilMessages[0].value.content.payload.fulfilment = 'condition'
 
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -1164,14 +1583,16 @@ Test('Transfer handler', transferHandlerTest => {
       TransferService.getById.returns(Promise.resolve({
         condition: 'condition',
         payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1',
         expirationDate: new Date('1900-01-01'),
         transferState: TransferState.RESERVED
       }))
       ilp.update.returns(Promise.resolve())
       Validator.validateFulfilCondition.returns(true)
       localfulfilMessages[0].value.content.headers['fspiop-source'] = 'dfsp2'
-      Kafka.proceed.returns(true)
+      localfulfilMessages[0].value.content.headers['fspiop-destination'] = 'dfsp1'
       localfulfilMessages[0].value.content.payload.fulfilment = 'condition'
+      Kafka.proceed.returns(true)
 
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
       TransferService.saveTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -1193,6 +1614,7 @@ Test('Transfer handler', transferHandlerTest => {
       TransferService.getById.returns(Promise.resolve({
         condition: 'condition',
         payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1',
         expirationDate: new Date('1900-01-01'),
         transferState: TransferState.RESERVED
       }))
@@ -1200,6 +1622,7 @@ Test('Transfer handler', transferHandlerTest => {
       Validator.validateFulfilCondition.returns(true)
       Kafka.proceed.returns(true)
       localfulfilMessages[0].value.content.headers['fspiop-source'] = 'dfsp2'
+      localfulfilMessages[0].value.content.headers['fspiop-destination'] = 'dfsp1'
       localfulfilMessages[0].value.content.payload.fulfilment = 'condition'
 
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -1272,6 +1695,7 @@ Test('Transfer handler', transferHandlerTest => {
       TransferService.getById.returns(Promise.resolve({
         condition: 'condition',
         payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1',
         expirationDate: new Date('1900-01-01'),
         transferState: TransferState.RESERVED
       }))
@@ -1280,6 +1704,7 @@ Test('Transfer handler', transferHandlerTest => {
       Validator.validateFulfilCondition.returns(true)
       Kafka.proceed.returns(true)
       localfulfilMessages[0].value.content.headers['fspiop-source'] = 'dfsp1'
+      localfulfilMessages[0].value.content.headers['fspiop-destination'] = 'dfsp1'
       localfulfilMessages[0].value.content.payload.fulfilment = 'condition'
 
       const result = await allTransferHandlers.fulfil(null, localfulfilMessages)
@@ -1295,12 +1720,14 @@ Test('Transfer handler', transferHandlerTest => {
       TransferService.getById.returns(Promise.resolve({
         condition: 'condition',
         payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1',
         expirationDate: new Date('1900-01-01'),
         transferState: TransferState.COMMITTED,
         transferStateEnumeration: TransferState.COMMITTED
       }))
       Kafka.proceed.returns(true)
       localfulfilMessages[0].value.content.headers['fspiop-source'] = 'dfsp2'
+      localfulfilMessages[0].value.content.headers['fspiop-destination'] = 'dfsp1'
       localfulfilMessages[0].value.content.payload.fulfilment = 'condition'
 
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -1323,12 +1750,14 @@ Test('Transfer handler', transferHandlerTest => {
       TransferService.getById.returns(Promise.resolve({
         condition: 'condition',
         payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1',
         expirationDate: new Date('1900-01-01'),
         transferState: TransferState.COMMITTED,
         transferStateEnumeration: TransferState.COMMITTED
       }))
       Kafka.proceed.returns(true)
       localfulfilMessages[0].value.content.headers['fspiop-source'] = 'dfsp2'
+      localfulfilMessages[0].value.content.headers['fspiop-destination'] = 'dfsp1'
       localfulfilMessages[0].value.content.payload.fulfilment = 'condition'
 
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -1351,12 +1780,14 @@ Test('Transfer handler', transferHandlerTest => {
       TransferService.getById.returns(Promise.resolve({
         condition: 'condition',
         payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1',
         expirationDate: new Date('1900-01-01'),
         transferState: TransferInternalState.RECEIVED_FULFIL,
         transferStateEnumeration: TransferState.RECEIVED
       }))
       Kafka.proceed.returns(true)
       localfulfilMessages[0].value.content.headers['fspiop-source'] = 'dfsp2'
+      localfulfilMessages[0].value.content.headers['fspiop-destination'] = 'dfsp1'
       localfulfilMessages[0].value.content.payload.fulfilment = 'condition'
 
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -1379,12 +1810,14 @@ Test('Transfer handler', transferHandlerTest => {
       TransferService.getById.returns(Promise.resolve({
         condition: 'condition',
         payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1',
         expirationDate: new Date('1900-01-01'),
         transferState: TransferState.RESERVED,
         transferStateEnumeration: TransferState.RESERVED
       }))
       Kafka.proceed.returns(true)
       localfulfilMessages[0].value.content.headers['fspiop-source'] = 'dfsp2'
+      localfulfilMessages[0].value.content.headers['fspiop-destination'] = 'dfsp1'
       localfulfilMessages[0].value.content.payload.fulfilment = 'condition'
 
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -1407,12 +1840,14 @@ Test('Transfer handler', transferHandlerTest => {
       TransferService.getById.returns(Promise.resolve({
         condition: 'condition',
         payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1',
         expirationDate: new Date('1900-01-01'),
         transferState: TransferInternalState.ABORTED_REJECTED,
         transferStateEnumeration: TransferState.ABORTED
       }))
       Kafka.proceed.returns(true)
       localfulfilMessages[0].value.content.headers['fspiop-source'] = 'dfsp2'
+      localfulfilMessages[0].value.content.headers['fspiop-destination'] = 'dfsp1'
       localfulfilMessages[0].value.content.payload.fulfilment = 'condition'
 
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -1435,12 +1870,14 @@ Test('Transfer handler', transferHandlerTest => {
       TransferService.getById.returns(Promise.resolve({
         condition: 'condition',
         payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1',
         expirationDate: new Date('1900-01-01'),
         transferState: undefined,
         transferStateEnumeration: undefined
       }))
       Kafka.proceed.returns(true)
       localfulfilMessages[0].value.content.headers['fspiop-source'] = 'dfsp2'
+      localfulfilMessages[0].value.content.headers['fspiop-destination'] = 'dfsp1'
       localfulfilMessages[0].value.content.payload.fulfilment = 'condition'
 
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -1463,12 +1900,14 @@ Test('Transfer handler', transferHandlerTest => {
       TransferService.getById.returns(Promise.resolve({
         condition: 'condition',
         payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1',
         expirationDate: new Date('1900-01-01'),
         transferState: TransferState.RESERVED,
         transferStateEnumeration: TransferState.RESERVED
       }))
       Kafka.proceed.returns(true)
       localfulfilMessages[0].value.content.headers['fspiop-source'] = 'dfsp2'
+      localfulfilMessages[0].value.content.headers['fspiop-destination'] = 'dfsp1'
       localfulfilMessages[0].value.content.payload.fulfilment = 'condition'
 
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -1491,12 +1930,14 @@ Test('Transfer handler', transferHandlerTest => {
       TransferService.getById.returns(Promise.resolve({
         condition: 'condition',
         payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1',
         expirationDate: new Date('1900-01-01'),
         transferState: TransferInternalState.ABORTED_ERROR,
         transferStateEnumeration: TransferState.ABORTED
       }))
       Kafka.proceed.returns(true)
       localfulfilMessages[0].value.content.headers['fspiop-source'] = 'dfsp2'
+      localfulfilMessages[0].value.content.headers['fspiop-destination'] = 'dfsp1'
       localfulfilMessages[0].value.content.payload.fulfilment = 'condition'
       localfulfilMessages[0].value.metadata.event.action = 'abort'
 
@@ -1520,12 +1961,14 @@ Test('Transfer handler', transferHandlerTest => {
       TransferService.getById.returns(Promise.resolve({
         condition: 'condition',
         payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1',
         expirationDate: new Date('1900-01-01'),
         transferState: TransferInternalState.ABORTED_ERROR,
         transferStateEnumeration: TransferState.ABORTED
       }))
       Kafka.proceed.returns(true)
       localfulfilMessages[0].value.content.headers['fspiop-source'] = 'dfsp2'
+      localfulfilMessages[0].value.content.headers['fspiop-destination'] = 'dfsp1'
       localfulfilMessages[0].value.content.payload.fulfilment = 'condition'
       localfulfilMessages[0].value.metadata.event.action = 'abort'
 
@@ -1549,12 +1992,14 @@ Test('Transfer handler', transferHandlerTest => {
       TransferService.getById.returns(Promise.resolve({
         condition: 'condition',
         payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1',
         expirationDate: new Date('1900-01-01'),
         transferState: TransferInternalState.ABORTED_ERROR,
         transferStateEnumeration: TransferState.ABORTED
       }))
       Kafka.proceed.returns(true)
       localfulfilMessages[0].value.content.headers['fspiop-source'] = 'dfsp2'
+      localfulfilMessages[0].value.content.headers['fspiop-destination'] = 'dfsp1'
       localfulfilMessages[0].value.content.payload.fulfilment = 'condition'
       localfulfilMessages[0].value.metadata.event.action = 'abort'
 
@@ -1578,10 +2023,12 @@ Test('Transfer handler', transferHandlerTest => {
       TransferService.getById.returns(Promise.resolve({
         condition: 'condition',
         payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1',
         transferState: TransferInternalState.RESERVED,
         transferStateEnumeration: TransferState.RESERVED
       }))
       invalidEventMessage.value.content.headers['fspiop-source'] = 'dfsp2'
+      invalidEventMessage.value.content.headers['fspiop-destination'] = 'dfsp1'
       invalidEventMessage.value.metadata.event.action = 'reject'
       Kafka.proceed.returns(true)
 
@@ -1606,10 +2053,12 @@ Test('Transfer handler', transferHandlerTest => {
       TransferService.getById.returns(Promise.resolve({
         condition: 'condition',
         payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1',
         transferState: TransferInternalState.RESERVED,
         transferStateEnumeration: TransferState.RESERVED
       }))
       invalidEventMessage.value.content.headers['fspiop-source'] = 'dfsp2'
+      invalidEventMessage.value.content.headers['fspiop-destination'] = 'dfsp1'
       invalidEventMessage.value.metadata.event.action = 'reject'
       Kafka.proceed.returns(true)
 
@@ -1633,6 +2082,7 @@ Test('Transfer handler', transferHandlerTest => {
       TransferService.getById.returns(Promise.resolve({
         condition: 'condition',
         payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1',
         transferState: TransferInternalState.RESERVED,
         transferStateEnumeration: TransferState.RESERVED
       }))
@@ -1667,11 +2117,13 @@ Test('Transfer handler', transferHandlerTest => {
       TransferService.getById.returns(Promise.resolve({
         condition: 'condition',
         payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1',
         transferState: TransferState.RESERVED
       }))
       TransferService.handlePayeeResponse.returns(Promise.resolve({ transferErrorRecord: { errorCode: '5000', errorDescription: 'error text' } }))
       invalidEventMessage.value.metadata.event.action = 'abort'
       invalidEventMessage.value.content.headers['fspiop-source'] = 'dfsp2'
+      invalidEventMessage.value.content.headers['fspiop-destination'] = 'dfsp1'
       Kafka.proceed.returns(true)
 
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -1694,12 +2146,14 @@ Test('Transfer handler', transferHandlerTest => {
       TransferService.getById.returns(Promise.resolve({
         condition: 'condition',
         payeeFsp: 'dfsp2',
+        payerFsp: 'dfsp1',
         transferState: TransferState.RESERVED
       }))
       TransferService.handlePayeeResponse.returns(Promise.resolve({ transferErrorRecord: { errorCode: '5000', errorDescription: 'error text' } }))
       invalidEventMessage.value.metadata.event.action = 'abort'
       invalidEventMessage.value.content.payload = errInfo
       invalidEventMessage.value.content.headers['fspiop-source'] = 'dfsp2'
+      invalidEventMessage.value.content.headers['fspiop-destination'] = 'dfsp1'
       Kafka.proceed.returns(true)
 
       TransferService.getTransferDuplicateCheck.returns(Promise.resolve(null))
@@ -1742,6 +2196,7 @@ Test('Transfer handler', transferHandlerTest => {
       TransferService.getById.returns(Promise.resolve({
         condition: 'condition',
         payeeFsp: 'dfsp1',
+        payerFsp: 'dfsp1',
         transferState: TransferState.RESERVED,
         transferStateEnumeration: TransferState.RESERVED
       }))