@mojaloop/sdk-scheme-adapter 12.3.0 → 13.0.2

package/test/unit/lib/model/OutboundTransfersModel.test.js

@@ -29,7 +29,7 @@ const quoteResponseTemplate = require('./data/quoteResponse');
 const transferFulfil = require('./data/transferFulfil');
 
 const genPartyId = (party) => {
-    const { partyIdType, partyIdentifier, partySubIdOrType } = party.party.partyIdInfo;
+    const { partyIdType, partyIdentifier, partySubIdOrType } = party.body.party.partyIdInfo;
     return PartiesModel.channelName({
         type: partyIdType,
         id: partyIdentifier,
@@ -39,6 +39,7 @@ const genPartyId = (party) => {
 
 // util function to simulate a party resolution subscription message on a cache client
 const emitPartyCacheMessage = (cache, party) => cache.publish(genPartyId(party), JSON.stringify(party));
+const emitMultiPartiesCacheMessage = (cache, party) => cache.add(genPartyId(party), JSON.stringify(party));
 
 // util function to simulate a quote response subscription message on a cache client
 const emitQuoteResponseCacheMessage = (cache, quoteId, quoteResponse) => cache.publish(`qt_${quoteId}`, JSON.stringify(quoteResponse));
@@ -46,6 +47,10 @@ const emitQuoteResponseCacheMessage = (cache, quoteId, quoteResponse) => cache.p
 // util function to simulate a transfer fulfilment subscription message on a cache client
 const emitTransferFulfilCacheMessage = (cache, transferId, fulfil) => cache.publish(`tf_${transferId}`, JSON.stringify(fulfil));
 
+const dummyRequestsModuleResponse = {
+    originalRequest: {}
+};
+
 describe('outboundModel', () => {
     let quoteResponse;
     let config;
@@ -73,13 +78,27 @@ describe('outboundModel', () => {
         config.rejectExpiredTransferFulfils = rejects.transferFulfils;
 
         // simulate a callback with the resolved party
-        MojaloopRequests.__getParties = jest.fn(() => emitPartyCacheMessage(cache, payeeParty));
+        MojaloopRequests.__getParties = jest.fn(() => {
+            emitPartyCacheMessage(cache, payeeParty);
+            return {
+                originalRequest: {
+                    headers: [],
+                    body: {},
+                }
+            };
+        });
 
         // simulate a delayed callback with the quote response
         MojaloopRequests.__postQuotes = jest.fn((postQuotesBody) => {
             setTimeout(() => {
                 emitQuoteResponseCacheMessage(cache, postQuotesBody.quoteId, quoteResponse);
             }, delays.requestQuotes ? delays.requestQuotes * 1000 : 0);
+            return {
+                originalRequest: {
+                    headers: [],
+                    body: postQuotesBody,
+                }
+            };
         });
 
         // simulate a delayed callback with the transfer fulfilment
@@ -87,6 +106,12 @@ describe('outboundModel', () => {
             setTimeout(() => {
                 emitTransferFulfilCacheMessage(cache, postTransfersBody.transferId, transferFulfil);
             }, delays.prepareTransfer ? delays.prepareTransfer * 1000 : 0);
+            return {
+                originalRequest: {
+                    headers: [],
+                    body: postTransfersBody,
+                }
+            };
         });
 
         const model = new Model({
@@ -121,13 +146,22 @@ describe('outboundModel', () => {
 
     beforeEach(async () => {
         config = JSON.parse(JSON.stringify(defaultConfig));
-        MojaloopRequests.__postParticipants = jest.fn(() => Promise.resolve());
-        MojaloopRequests.__getParties = jest.fn(() => Promise.resolve());
-        MojaloopRequests.__postQuotes = jest.fn(() => Promise.resolve());
-        MojaloopRequests.__putQuotes = jest.fn(() => Promise.resolve());
-        MojaloopRequests.__putQuotesError = jest.fn(() => Promise.resolve());
-        MojaloopRequests.__postTransfers = jest.fn(() => Promise.resolve());
-
+        MojaloopRequests.__postParticipants = jest.fn(() => Promise.resolve(dummyRequestsModuleResponse));
+        MojaloopRequests.__getParties = jest.fn(() => Promise.resolve(dummyRequestsModuleResponse));
+        MojaloopRequests.__putQuotes = jest.fn(() => Promise.resolve(dummyRequestsModuleResponse));
+        MojaloopRequests.__putQuotesError = jest.fn(() => Promise.resolve(dummyRequestsModuleResponse));
+        MojaloopRequests.__postQuotes = jest.fn((body) => Promise.resolve({
+            originalRequest: {
+                headers: [],
+                body: body,
+            }
+        }));
+        MojaloopRequests.__postTransfers = jest.fn((body) => Promise.resolve({
+            originalRequest: {
+                headers: [],
+                body: body,
+            }
+        }));
         cache = new Cache({
             host: 'dummycachehost',
             port: 1234,
@@ -152,14 +186,13 @@ describe('outboundModel', () => {
         expect(StateMachine.__instance.state).toBe('start');
     });
 
-
     test('executes all three transfer stages without halting when AUTO_ACCEPT_PARTY and AUTO_ACCEPT_QUOTES are true', async () => {
         config.autoAcceptParty = true;
         config.autoAcceptQuotes = true;
 
         MojaloopRequests.__getParties = jest.fn(() => {
             emitPartyCacheMessage(cache, payeeParty);
-            return Promise.resolve();
+            return Promise.resolve(dummyRequestsModuleResponse);
         });
 
         MojaloopRequests.__postQuotes = jest.fn((postQuotesBody) => {
@@ -173,13 +206,13 @@ describe('outboundModel', () => {
 
             // simulate a callback with the quote response
             emitQuoteResponseCacheMessage(cache, postQuotesBody.quoteId, quoteResponse);
-            return Promise.resolve();
+            return Promise.resolve(dummyRequestsModuleResponse);
         });
 
         MojaloopRequests.__postTransfers = jest.fn((postTransfersBody, destFspId) => {
             //ensure that the `MojaloopRequests.postTransfers` method has been called with the correct arguments
             // set as the destination FSPID, picked up from the header's value `fspiop-source`
-            expect(model.data.quoteResponseSource).toBe(quoteResponse.headers['fspiop-source']);
+            expect(model.data.quoteResponseSource).toBe(quoteResponse.data.headers['fspiop-source']);
 
             const extensionList = postTransfersBody.extensionList.extension;
             expect(extensionList).toBeTruthy();
@@ -187,12 +220,190 @@ describe('outboundModel', () => {
             expect(extensionList[0]).toEqual({ key: 'tkey1', value: 'tvalue1' });
             expect(extensionList[1]).toEqual({ key: 'tkey2', value: 'tvalue2' });
 
-            expect(destFspId).toBe(quoteResponse.headers['fspiop-source']);
-            expect(model.data.to.fspId).toBe(payeeParty.party.partyIdInfo.fspId);
-            expect(quoteResponse.headers['fspiop-source']).not.toBe(model.data.to.fspId);
+            expect(destFspId).toBe(quoteResponse.data.headers['fspiop-source']);
+            expect(model.data.to.fspId).toBe(payeeParty.body.party.partyIdInfo.fspId);
+            expect(quoteResponse.data.headers['fspiop-source']).not.toBe(model.data.to.fspId);
 
             // simulate a callback with the transfer fulfilment
             emitTransferFulfilCacheMessage(cache, postTransfersBody.transferId, transferFulfil);
+            return Promise.resolve(dummyRequestsModuleResponse);
+        });
+
+        const model = new Model({
+            cache,
+            logger,
+            metricsClient,
+            ...config,
+        });
+
+        await model.initialize(JSON.parse(JSON.stringify(transferRequest)));
+
+        expect(StateMachine.__instance.state).toBe('start');
+
+        // start the model running
+        const result = await model.run();
+
+        expect(MojaloopRequests.__getParties).toHaveBeenCalledTimes(1);
+        expect(MojaloopRequests.__postQuotes).toHaveBeenCalledTimes(1);
+        expect(MojaloopRequests.__postTransfers).toHaveBeenCalledTimes(1);
+
+        // make sure no PATCH was sent as we did not set config or receive a RESERVED state
+        expect(MojaloopRequests.__patchTransfers).toHaveBeenCalledTimes(0);
+
+        // check we stopped at payeeResolved state
+        expect(result.currentState).toBe('COMPLETED');
+        expect(StateMachine.__instance.state).toBe('succeeded');
+    });
+
+    test('sends a PATCH /transfers/{transferId} request to payee DFSP when SEND_FINAL_NOTIFICATION_IF_REQUESTED is true', async () => {
+        config.autoAcceptParty = true;
+        config.autoAcceptQuotes = true;
+        config.sendFinalNotificationIfRequested = true;
+        MojaloopRequests.__getParties = jest.fn(() => {
+            emitPartyCacheMessage(cache, payeeParty);
+            return Promise.resolve(dummyRequestsModuleResponse);
+        });
+        MojaloopRequests.__postQuotes = jest.fn((postQuotesBody) => {
+            // ensure that the `MojaloopRequests.postQuotes` method has been called with correct arguments
+            // including extension list
+            const extensionList = postQuotesBody.extensionList.extension;
+            expect(extensionList).toBeTruthy();
+            expect(extensionList.length).toBe(2);
+            expect(extensionList[0]).toEqual({ key: 'qkey1', value: 'qvalue1' });
+            expect(extensionList[1]).toEqual({ key: 'qkey2', value: 'qvalue2' });
+            // simulate a callback with the quote response
+            emitQuoteResponseCacheMessage(cache, postQuotesBody.quoteId, quoteResponse);
+            return Promise.resolve(dummyRequestsModuleResponse);
+        });
+        const pb = JSON.parse(JSON.stringify(transferFulfil));
+        pb.data.body.transferState = 'RESERVED';
+        MojaloopRequests.__postTransfers = jest.fn((postTransfersBody, destFspId) => {
+            //ensure that the `MojaloopRequests.postTransfers` method has been called with the correct arguments
+            // set as the destination FSPID, picked up from the header's value `fspiop-source`
+            expect(model.data.quoteResponseSource).toBe(quoteResponse.data.headers['fspiop-source']);
+            const extensionList = postTransfersBody.extensionList.extension;
+            expect(extensionList).toBeTruthy();
+            expect(extensionList.length).toBe(2);
+            expect(extensionList[0]).toEqual({ key: 'tkey1', value: 'tvalue1' });
+            expect(extensionList[1]).toEqual({ key: 'tkey2', value: 'tvalue2' });
+            expect(destFspId).toBe(quoteResponse.data.headers['fspiop-source']);
+            expect(model.data.to.fspId).toBe(payeeParty.body.party.partyIdInfo.fspId);
+            expect(quoteResponse.data.headers['fspiop-source']).not.toBe(model.data.to.fspId);
+            // simulate a callback with the transfer fulfilment
+            emitTransferFulfilCacheMessage(cache, postTransfersBody.transferId, pb);
+            return Promise.resolve(dummyRequestsModuleResponse);
+        });
+        const model = new Model({
+            cache,
+            logger,
+            metricsClient,
+            ...config,
+        });
+        await model.initialize(JSON.parse(JSON.stringify(transferRequest)));
+        expect(StateMachine.__instance.state).toBe('start');
+        // start the model running
+        const result = await model.run();
+        expect(MojaloopRequests.__getParties).toHaveBeenCalledTimes(1);
+        expect(MojaloopRequests.__postQuotes).toHaveBeenCalledTimes(1);
+        expect(MojaloopRequests.__postTransfers).toHaveBeenCalledTimes(1);
+        expect(MojaloopRequests.__patchTransfers).toHaveBeenCalledTimes(1);
+        expect(MojaloopRequests.__patchTransfers.mock.calls[0][0]).toEqual(model.data.transferId);
+        expect(MojaloopRequests.__patchTransfers.mock.calls[0][1].transferState).toEqual('COMMITTED');
+        expect(MojaloopRequests.__patchTransfers.mock.calls[0][1].completedTimestamp).not.toBeUndefined();
+        expect(MojaloopRequests.__patchTransfers.mock.calls[0][2]).toEqual(quoteResponse.data.headers['fspiop-source']);
+
+
+        // check we stopped at payeeResolved state
+        expect(result.currentState).toBe('COMPLETED');
+        expect(StateMachine.__instance.state).toBe('succeeded');
+    });
+
+    test('uses quote response transfer amount for transfer prepare', async () => {
+        config.autoAcceptParty = true;
+        config.autoAcceptQuotes = true;
+
+        MojaloopRequests.__getParties = jest.fn(() => {
+            emitPartyCacheMessage(cache, payeeParty);
+            return Promise.resolve(dummyRequestsModuleResponse);
+        });
+
+        // change the the transfer amount and currency in the quote response
+        // so it is different to the initial request
+        quoteResponse.data.body.transferAmount = {
+            currency: 'XYZ',
+            amount: '9876543210'
+        };
+
+        expect(quoteResponse.data.body.transferAmount).not.toEqual({
+            amount: transferRequest.amount,
+            currency: transferRequest.currency
+        });
+
+        MojaloopRequests.__postQuotes = jest.fn((postQuotesBody) => {
+            // ensure that the `MojaloopRequests.postQuotes` method has been called with correct arguments
+            // including extension list
+            const extensionList = postQuotesBody.extensionList.extension;
+            expect(extensionList).toBeTruthy();
+            expect(extensionList.length).toBe(2);
+            expect(extensionList[0]).toEqual({ key: 'qkey1', value: 'qvalue1' });
+            expect(extensionList[1]).toEqual({ key: 'qkey2', value: 'qvalue2' });
+
+            // simulate a callback with the quote response
+            emitQuoteResponseCacheMessage(cache, postQuotesBody.quoteId, quoteResponse);
+            return Promise.resolve(dummyRequestsModuleResponse);
+        });
+
+        MojaloopRequests.__postTransfers = jest.fn((postTransfersBody, destFspId) => {
+            //ensure that the `MojaloopRequests.postTransfers` method has been called with the correct arguments
+            // set as the destination FSPID, picked up from the header's value `fspiop-source`
+            expect(model.data.quoteResponseSource).toBe(quoteResponse.data.headers['fspiop-source']);
+
+            const extensionList = postTransfersBody.extensionList.extension;
+            expect(extensionList).toBeTruthy();
+            expect(extensionList.length).toBe(2);
+            expect(extensionList[0]).toEqual({ key: 'tkey1', value: 'tvalue1' });
+            expect(extensionList[1]).toEqual({ key: 'tkey2', value: 'tvalue2' });
+
+            expect(destFspId).toBe(quoteResponse.data.headers['fspiop-source']);
+            expect(model.data.to.fspId).toBe(payeeParty.body.party.partyIdInfo.fspId);
+            expect(quoteResponse.data.headers['fspiop-source']).not.toBe(model.data.to.fspId);
+
+            expect(postTransfersBody.amount).toEqual(quoteResponse.data.body.transferAmount);
+
+            // simulate a callback with the transfer fulfilment
+            emitTransferFulfilCacheMessage(cache, postTransfersBody.transferId, transferFulfil);
+            return Promise.resolve(dummyRequestsModuleResponse);
+        });
+
+        const model = new Model({
+            cache,
+            logger,
+            metricsClient,
+            ...config,
+        });
+
+        await model.initialize(JSON.parse(JSON.stringify(transferRequest)));
+
+        expect(StateMachine.__instance.state).toBe('start');
+
+        // start the model running
+        const result = await model.run();
+
+        expect(MojaloopRequests.__getParties).toHaveBeenCalledTimes(1);
+        expect(MojaloopRequests.__postQuotes).toHaveBeenCalledTimes(1);
+        expect(MojaloopRequests.__postTransfers).toHaveBeenCalledTimes(1);
+
+        // make sure no PATCH was sent as we did not set config or receive a RESERVED state
+        expect(MojaloopRequests.__patchTransfers).toHaveBeenCalledTimes(0);
+
+        // check we stopped at payeeResolved state
+        expect(result.currentState).toBe('COMPLETED');
+        expect(StateMachine.__instance.state).toBe('succeeded');
+    });
+
+    test('test get transfer', async () => {
+        MojaloopRequests.__getTransfers = jest.fn((transferId) => {
+            emitTransferFulfilCacheMessage(cache, transferId, transferFulfil);
             return Promise.resolve();
         });
 
@@ -203,81 +414,470 @@ describe('outboundModel', () => {
             ...config,
         });
 
-        await model.initialize(JSON.parse(JSON.stringify(transferRequest)));
+        const TRANSFER_ID = 'tx-id000011';
+
+        await model.initialize(JSON.parse(JSON.stringify({
+            ...transferRequest,
+            currentState: 'getTransfer',
+            transferId: TRANSFER_ID,
+        })));
+
+        expect(StateMachine.__instance.state).toBe('getTransfer');
+
+        // start the model running
+        const result = await model.run();
+
+        expect(MojaloopRequests.__getTransfers).toHaveBeenCalledTimes(1);
+
+        // check we stopped at payeeResolved state
+        expect(result.currentState).toBe('COMPLETED');
+        expect(StateMachine.__instance.state).toBe('succeeded');
+    });
+
+
+    test('resolves payee and halts when AUTO_ACCEPT_PARTY is false', async () => {
+        config.autoAcceptParty = false;
+
+        const model = new Model({
+            cache,
+            logger,
+            metricsClient,
+            ...config,
+        });
+
+        await model.initialize(JSON.parse(JSON.stringify(transferRequest)));
+
+        expect(StateMachine.__instance.state).toBe('start');
+
+        // start the model running
+        const resultPromise = model.run();
+
+        // now we started the model running we simulate a callback with the resolved party
+        emitPartyCacheMessage(cache, payeeParty);
+
+        // wait for the model to reach a terminal state
+        const result = await resultPromise;
+
+        // check we stopped at payeeResolved state
+        expect(result.currentState).toBe('WAITING_FOR_PARTY_ACCEPTANCE');
+        expect(StateMachine.__instance.state).toBe('payeeResolved');
+    });
+
+    test('uses payee party fspid as source header when supplied - resolving payee', async () => {
+        config.autoAcceptParty = false;
+
+        const model = new Model({
+            cache,
+            logger,
+            metricsClient,
+            ...config,
+        });
+
+        let req = JSON.parse(JSON.stringify(transferRequest));
+        const testFspId = 'TESTDESTFSPID';
+        req.to.fspId = testFspId;
+
+        await model.initialize(req);
+
+        expect(StateMachine.__instance.state).toBe('start');
+
+        // start the model running
+        const resultPromise = model.run();
+
+        // now we started the model running we simulate a callback with the resolved party
+        emitPartyCacheMessage(cache, payeeParty);
+
+        // wait for the model to reach a terminal state
+        const result = await resultPromise;
+
+        // check we stopped at payeeResolved state
+        expect(result.currentState).toBe('WAITING_FOR_PARTY_ACCEPTANCE');
+        expect(StateMachine.__instance.state).toBe('payeeResolved');
+
+        // check getParties mojaloop requests method was called with the correct arguments
+        expect(MojaloopRequests.__getParties).toHaveBeenCalledWith(req.to.idType, req.to.idValue, req.to.idSubValue, testFspId);
+    });
+
+    test('resolves multiple payees and halts', async () => {
+        config.autoAcceptParty = false;
+        config.multiplePartiesResponse = true;
+        config.multiplePartiesResponseSeconds = 2;
+        const model = new Model({
+            cache,
+            logger,
+            metricsClient,
+            ...config,
+        });
+        await model.initialize(JSON.parse(JSON.stringify(transferRequest)));
+        expect(StateMachine.__instance.state).toBe('start');
+        // start the model running
+        const resultPromise = model.run();
+        // now we started the model running we simulate a callback with the resolved party
+        const payeeParty1 = JSON.parse(JSON.stringify(payeeParty));
+        payeeParty1.body.party.partyIdInfo.fspId = 'FirstFspId';
+        await emitMultiPartiesCacheMessage(cache, payeeParty1);
+        const payeeParty2 = JSON.parse(JSON.stringify(payeeParty));
+        payeeParty2.body.party.partyIdInfo.fspId = 'SecondFspId';
+        await emitMultiPartiesCacheMessage(cache, payeeParty2);
+        // wait for the model to reach a terminal state
+        const result = await resultPromise;
+        // check we stopped at payeeResolved state
+        expect(result.currentState).toBe('WAITING_FOR_PARTY_ACCEPTANCE');
+        expect(StateMachine.__instance.state).toBe('payeeResolved');
+        expect(result.to[0].fspId).toEqual('FirstFspId');
+        expect(result.to[1].fspId).toEqual('SecondFspId');
+    });
+
+    test('halts after resolving payee, resumes and then halts after receiving quote response when AUTO_ACCEPT_PARTY is false and AUTO_ACCEPT_QUOTES is false', async () => {
+        config.autoAcceptParty = false;
+        config.autoAcceptQuotes = false;
+
+        let model = new Model({
+            cache,
+            logger,
+            metricsClient,
+            ...config,
+        });
+
+        await model.initialize(JSON.parse(JSON.stringify(transferRequest)));
+
+        expect(StateMachine.__instance.state).toBe('start');
+
+        // start the model running
+        let resultPromise = model.run();
+
+        // now we started the model running we simulate a callback with the resolved party
+        emitPartyCacheMessage(cache, payeeParty);
+
+        // wait for the model to reach a terminal state
+        let result = await resultPromise;
+
+        // check we stopped at payeeResolved state
+        expect(result.currentState).toBe('WAITING_FOR_PARTY_ACCEPTANCE');
+        expect(StateMachine.__instance.state).toBe('payeeResolved');
+
+        const transferId = result.transferId;
+
+        // load a new model from the saved state
+        model = new Model({
+            cache,
+            logger,
+            metricsClient,
+            ...config,
+        });
+
+        await model.load(transferId);
+
+        // check the model loaded to the correct state
+        expect(StateMachine.__instance.state).toBe('payeeResolved');
+
+        // now run the model again. this should trigger transition to quote request
+        resultPromise = model.run({ acceptParty: true });
+        // now we started the model running we simulate a callback with the quote response
+        cache.publish(`qt_${model.data.quoteId}`, JSON.stringify(quoteResponse));
+
+        // wait for the model to reach a terminal state
+        result = await resultPromise;
+
+        // check we stopped at payeeResolved state
+        expect(result.currentState).toBe('WAITING_FOR_QUOTE_ACCEPTANCE');
+        expect(StateMachine.__instance.state).toBe('quoteReceived');
+    });
+
+    test('Allows change of transferAmount at accept party phase', async () => {
+        config.autoAcceptParty = false;
+        config.autoAcceptQuotes = false;
+
+        let model = new Model({
+            cache,
+            logger,
+            metricsClient,
+            ...config,
+        });
+
+        const req = JSON.parse(JSON.stringify(transferRequest));
+
+        // record the initial requested transfer amount
+        const initialAmount = req.amount;
+
+        await model.initialize(req);
+
+        expect(StateMachine.__instance.state).toBe('start');
+
+        // start the model running
+        let resultPromise = model.run();
+
+        // now we started the model running we simulate a callback with the resolved party
+        emitPartyCacheMessage(cache, payeeParty);
+
+        // wait for the model to reach a terminal state
+        let result = await resultPromise;
+
+        // check we stopped at payeeResolved state
+        expect(result.currentState).toBe('WAITING_FOR_PARTY_ACCEPTANCE');
+        expect(StateMachine.__instance.state).toBe('payeeResolved');
+
+        expect(result.amount).toEqual(initialAmount);
+
+        const transferId = result.transferId;
+
+        // load a new model from the saved state
+        model = new Model({
+            cache,
+            logger,
+            metricsClient,
+            ...config,
+        });
+
+        await model.load(transferId);
+
+        // check the model loaded to the correct state
+        expect(StateMachine.__instance.state).toBe('payeeResolved');
+
+        const resume = {
+            amount: 999,
+            acceptParty: true,
+        };
+
+        // now run the model again. this should trigger transition to quote request
+        resultPromise = model.run(resume);
+
+        // now we started the model running we simulate a callback with the quote response
+        cache.publish(`qt_${model.data.quoteId}`, JSON.stringify(quoteResponse));
+
+        // wait for the model to reach a terminal state
+        result = await resultPromise;
+
+        // check we stopped at quoteReceived state
+        expect(result.currentState).toBe('WAITING_FOR_QUOTE_ACCEPTANCE');
+        expect(StateMachine.__instance.state).toBe('quoteReceived');
+
+        // check the accept party key got merged to the state
+        expect(result.acceptParty).toEqual(true);
+
+        // check the amount key got changed
+        expect(result.amount).toEqual(resume.amount);
+
+        // check the quote request amount is the NEW amount, not the initial amount
+        expect(result.quoteRequest.body.amount.amount).toStrictEqual(resume.amount);
+        expect(result.quoteRequest.body.amount.amount).not.toEqual(initialAmount);
+    });
+
+    test('Allows change of payee party at accept party phase (round-robin support)', async () => {
+        config.autoAcceptParty = false;
+        config.autoAcceptQuotes = false;
+
+        let model = new Model({
+            cache,
+            logger,
+            metricsClient,
+            ...config,
+        });
+
+        const req = JSON.parse(JSON.stringify(transferRequest));
+
+        // record the initial requested transfer amount
+        const initialAmount = req.amount;
+
+        await model.initialize(req);
+
+        expect(StateMachine.__instance.state).toBe('start');
+
+        // start the model running
+        let resultPromise = model.run();
+
+        // now we started the model running we simulate a callback with the resolved party
+        emitPartyCacheMessage(cache, payeeParty);
+
+        // wait for the model to reach a terminal state
+        let result = await resultPromise;
+
+        // check we stopped at payeeResolved state
+        expect(result.currentState).toBe('WAITING_FOR_PARTY_ACCEPTANCE');
+        expect(StateMachine.__instance.state).toBe('payeeResolved');
+
+        expect(result.amount).toEqual(initialAmount);
+
+        const transferId = result.transferId;
+
+        // load a new model from the saved state
+        model = new Model({
+            cache,
+            logger,
+            metricsClient,
+            ...config,
+        });
+
+        await model.load(transferId);
+
+        // check the model loaded to the correct state
+        expect(StateMachine.__instance.state).toBe('payeeResolved');
+
+        const newPayee = {
+            partyIdInfo: {
+                partySubIdOrType: undefined,
+                partyIdType: 'PASSPORT',
+                partyIdentifier: 'AAABBBCCCDDDEEE',
+                fspId: 'TESTDFSP'
+            }
+        };
+
+        const newPayeeInternal = {
+            idType: newPayee.partyIdInfo.partyIdType,
+            idValue: newPayee.partyIdInfo.partyIdentifier,
+            fspId: newPayee.partyIdInfo.fspId,
+        };
+
+        const resume = {
+            acceptParty: true,
+            to: newPayeeInternal,
+        };
+
+        // now run the model again. this should trigger transition to quote request
+        resultPromise = model.run(resume);
+
+        // now we started the model running we simulate a callback with the quote response
+        cache.publish(`qt_${model.data.quoteId}`, JSON.stringify(quoteResponse));
+
+        // wait for the model to reach a terminal state
+        result = await resultPromise;
+
+        // check we stopped at quoteReceived state
+        expect(result.currentState).toBe('WAITING_FOR_QUOTE_ACCEPTANCE');
+        expect(StateMachine.__instance.state).toBe('quoteReceived');
+
+        // check the accept party key got merged to the state
+        expect(result.acceptParty).toEqual(true);
+
+        // check the "to" passed in to model resume is merged into the model state correctly
+        expect(result.to).toStrictEqual(newPayeeInternal);
+
+        // check the quote request payee party is the NEW one, not the initial one.
+        expect(result.quoteRequest.body.payee).toStrictEqual(newPayee);
+    });
+
+    test('Does not merge resume data keys into state that are not permitted', async () => {
+        config.autoAcceptParty = false;
+        config.autoAcceptQuotes = false;
+
+        let model = new Model({
+            cache,
+            logger,
+            metricsClient,
+            ...config,
+        });
+
+        const req = JSON.parse(JSON.stringify(transferRequest));
+
+        // record the initial requested transfer amount
+        const initialAmount = req.amount;
+
+        await model.initialize(req);
+
+        expect(StateMachine.__instance.state).toBe('start');
+
+        // start the model running
+        let resultPromise = model.run();
+
+        // now we started the model running we simulate a callback with the resolved party
+        emitPartyCacheMessage(cache, payeeParty);
+
+        // wait for the model to reach a terminal state
+        let result = await resultPromise;
+
+        // check we stopped at payeeResolved state
+        expect(result.currentState).toBe('WAITING_FOR_PARTY_ACCEPTANCE');
+        expect(StateMachine.__instance.state).toBe('payeeResolved');
+
+        expect(result.amount).toEqual(initialAmount);
+
+        const transferId = result.transferId;
+
+        // load a new model from the saved state
+        model = new Model({
+            cache,
+            logger,
+            metricsClient,
+            ...config,
+        });
+
+        await model.load(transferId);
 
-        expect(StateMachine.__instance.state).toBe('start');
+        // check the model loaded to the correct state
+        expect(StateMachine.__instance.state).toBe('payeeResolved');
 
-        // start the model running
-        const result = await model.run();
+        const resume = {
+            amount: 999,
+            acceptParty: true,
+            someRandomKey: 'this key name is not permitted',
+        };
 
-        expect(MojaloopRequests.__getParties).toHaveBeenCalledTimes(1);
-        expect(MojaloopRequests.__postQuotes).toHaveBeenCalledTimes(1);
-        expect(MojaloopRequests.__postTransfers).toHaveBeenCalledTimes(1);
+        // now run the model again. this should trigger transition to quote request
+        resultPromise = model.run(resume);
 
-        // check we stopped at payeeResolved state
-        expect(result.currentState).toBe('COMPLETED');
-        expect(StateMachine.__instance.state).toBe('succeeded');
-    });
+        // now we started the model running we simulate a callback with the quote response
+        cache.publish(`qt_${model.data.quoteId}`, JSON.stringify(quoteResponse));
 
+        // wait for the model to reach a terminal state
+        result = await resultPromise;
 
-    test('uses quote response transfer amount for transfer prepare', async () => {
-        config.autoAcceptParty = true;
-        config.autoAcceptQuotes = true;
+        // check we stopped at quoteReceived state
+        expect(result.currentState).toBe('WAITING_FOR_QUOTE_ACCEPTANCE');
+        expect(StateMachine.__instance.state).toBe('quoteReceived');
 
-        MojaloopRequests.__getParties = jest.fn(() => {
-            emitPartyCacheMessage(cache, payeeParty);
-            return Promise.resolve();
-        });
+        // check the accept party key got merged to the state
+        expect(result.acceptParty).toEqual(true);
 
-        // change the the transfer amount and currency in the quote response
-        // so it is different to the initial request
-        quoteResponse.data.transferAmount = {
-            currency: 'XYZ',
-            amount: '9876543210'
-        };
+        // check the amount key got changed
+        expect(result.amount).toEqual(resume.amount);
 
-        expect(quoteResponse.data.transferAmount).not.toEqual({
-            amount: transferRequest.amount,
-            currency: transferRequest.currency
-        });
+        // check the quote request amount is the NEW amount, not the initial amount
+        expect(result.quoteRequest.body.amount.amount).toStrictEqual(resume.amount);
+        expect(result.quoteRequest.body.amount.amount).not.toEqual(initialAmount);
 
-        MojaloopRequests.__postQuotes = jest.fn((postQuotesBody) => {
-            // ensure that the `MojaloopRequests.postQuotes` method has been called with correct arguments
-            // including extension list
-            const extensionList = postQuotesBody.extensionList.extension;
-            expect(extensionList).toBeTruthy();
-            expect(extensionList.length).toBe(2);
-            expect(extensionList[0]).toEqual({ key: 'qkey1', value: 'qvalue1' });
-            expect(extensionList[1]).toEqual({ key: 'qkey2', value: 'qvalue2' });
+        // check that our disallowed key is not merged to the transfer state
+        expect(result.someRandomKey).toBeUndefined();
+    });
 
-            // simulate a callback with the quote response
-            emitQuoteResponseCacheMessage(cache, postQuotesBody.quoteId, quoteResponse);
-            return Promise.resolve();
+    test('skips resolving party when to.fspid is specified and skipPartyLookup is truthy', async () => {
+        config.autoAcceptParty = false;
+        config.autoAcceptQuotes = false;
+
+        let model = new Model({
+            cache,
+            logger,
+            metricsClient,
+            ...config,
         });
 
-        MojaloopRequests.__postTransfers = jest.fn((postTransfersBody, destFspId) => {
-            //ensure that the `MojaloopRequests.postTransfers` method has been called with the correct arguments
-            // set as the destination FSPID, picked up from the header's value `fspiop-source`
-            expect(model.data.quoteResponseSource).toBe(quoteResponse.headers['fspiop-source']);
+        let req = JSON.parse(JSON.stringify(transferRequest));
+        const testFspId = 'TESTDESTFSPID';
+        req.to.fspId = testFspId;
+        req.skipPartyLookup = true;
 
-            const extensionList = postTransfersBody.extensionList.extension;
-            expect(extensionList).toBeTruthy();
-            expect(extensionList.length).toBe(2);
-            expect(extensionList[0]).toEqual({ key: 'tkey1', value: 'tvalue1' });
-            expect(extensionList[1]).toEqual({ key: 'tkey2', value: 'tvalue2' });
+        await model.initialize(req);
 
-            expect(destFspId).toBe(quoteResponse.headers['fspiop-source']);
-            expect(model.data.to.fspId).toBe(payeeParty.party.partyIdInfo.fspId);
-            expect(quoteResponse.headers['fspiop-source']).not.toBe(model.data.to.fspId);
+        expect(StateMachine.__instance.state).toBe('start');
 
-            expect(postTransfersBody.amount).toEqual(quoteResponse.data.transferAmount);
+        // start the model running
+        let resultPromise = model.run();
 
-            // simulate a callback with the transfer fulfilment
-            emitTransferFulfilCacheMessage(cache, postTransfersBody.transferId, transferFulfil);
-            return Promise.resolve();
-        });
+        // now we started the model running we simulate a callback with the quote response
+        cache.publish(`qt_${model.data.quoteId}`, JSON.stringify(quoteResponse));
 
-        const model = new Model({
+        // wait for the model to reach a terminal state
+        let result = await resultPromise;
+
+        // check we stopped at quoteReceived state
+        expect(result.currentState).toBe('WAITING_FOR_QUOTE_ACCEPTANCE');
+        expect(StateMachine.__instance.state).toBe('quoteReceived');
+    });
+
+    test('aborts after party rejected by backend', async () => {
+        config.autoAcceptParty = false;
+        config.autoAcceptQuotes = false;
+
+        let model = new Model({
             cache,
             logger,
             metricsClient,
@@ -289,56 +889,47 @@ describe('outboundModel', () => {
         expect(StateMachine.__instance.state).toBe('start');
 
         // start the model running
-        const result = await model.run();
+        let resultPromise = model.run();
 
-        expect(MojaloopRequests.__getParties).toHaveBeenCalledTimes(1);
-        expect(MojaloopRequests.__postQuotes).toHaveBeenCalledTimes(1);
-        expect(MojaloopRequests.__postTransfers).toHaveBeenCalledTimes(1);
+        // now we started the model running we simulate a callback with the resolved party
+        emitPartyCacheMessage(cache, payeeParty);
 
-        // check we stopped at payeeResolved state
-        expect(result.currentState).toBe('COMPLETED');
-        expect(StateMachine.__instance.state).toBe('succeeded');
-    });
+        // wait for the model to reach a terminal state
+        let result = await resultPromise;
 
+        // check we stopped at payeeResolved state
+        expect(result.currentState).toBe('WAITING_FOR_PARTY_ACCEPTANCE');
+        expect(StateMachine.__instance.state).toBe('payeeResolved');
 
-    test('test get transfer', async () => {
-        MojaloopRequests.__getTransfers = jest.fn((transferId) => {
-            emitTransferFulfilCacheMessage(cache, transferId, transferFulfil);
-            return Promise.resolve();
-        });
+        const transferId = result.transferId;
 
-        const model = new Model({
+        // load a new model from the saved state
+        model = new Model({
             cache,
             logger,
             metricsClient,
             ...config,
         });
 
-        const TRANSFER_ID = 'tx-id000011';
-
-        await model.initialize(JSON.parse(JSON.stringify({
-            ...transferRequest,
-            currentState: 'getTransfer',
-            transferId: TRANSFER_ID,
-        })));
-
-        expect(StateMachine.__instance.state).toBe('getTransfer');
+        await model.load(transferId);
 
-        // start the model running
-        const result = await model.run();
+        // check the model loaded to the correct state
+        expect(StateMachine.__instance.state).toBe('payeeResolved');
 
-        expect(MojaloopRequests.__getTransfers).toHaveBeenCalledTimes(1);
+        // now run the model again with a party rejection. this should trigger transition to quote request
+        result = await model.run({ resume: { acceptParty: false } });
 
-        // check we stopped at payeeResolved state
-        expect(result.currentState).toBe('COMPLETED');
-        expect(StateMachine.__instance.state).toBe('succeeded');
+        // check we stopped at quoteReceived state
+        expect(result.currentState).toBe('ABORTED');
+        expect(result.abortedReason).toBe('Payee rejected by backend');
+        expect(StateMachine.__instance.state).toBe('aborted');
     });
 
-
-    test('resolves payee and halts when AUTO_ACCEPT_PARTY is false', async () => {
+    test('aborts after quote rejected by backend', async () => {
         config.autoAcceptParty = false;
+        config.autoAcceptQuotes = false;
 
-        const model = new Model({
+        let model = new Model({
             cache,
             logger,
             metricsClient,
@@ -350,55 +941,81 @@ describe('outboundModel', () => {
         expect(StateMachine.__instance.state).toBe('start');
 
         // start the model running
-        const resultPromise = model.run();
+        let resultPromise = model.run();
 
         // now we started the model running we simulate a callback with the resolved party
         emitPartyCacheMessage(cache, payeeParty);
 
         // wait for the model to reach a terminal state
-        const result = await resultPromise;
+        let result = await resultPromise;
 
         // check we stopped at payeeResolved state
         expect(result.currentState).toBe('WAITING_FOR_PARTY_ACCEPTANCE');
         expect(StateMachine.__instance.state).toBe('payeeResolved');
-    });
 
-    test('uses payee party fspid as source header when supplied - resolving payee', async () => {
-        config.autoAcceptParty = false;
+        const transferId = result.transferId;
 
-        const model = new Model({
+        // load a new model from the saved state
+        model = new Model({
             cache,
             logger,
             metricsClient,
             ...config,
         });
 
-        let req = JSON.parse(JSON.stringify(transferRequest));
-        const testFspId = 'TESTDESTFSPID';
-        req.to.fspId = testFspId;
-
-        await model.initialize(req);
+        await model.load(transferId);
 
-        expect(StateMachine.__instance.state).toBe('start');
+        // check the model loaded to the correct state
+        expect(StateMachine.__instance.state).toBe('payeeResolved');
 
-        // start the model running
-        const resultPromise = model.run();
+        // now run the model again. this should trigger transition to quote request
+        resultPromise = model.run({ acceptParty: true });
 
-        // now we started the model running we simulate a callback with the resolved party
-        emitPartyCacheMessage(cache, payeeParty);
+        // now we started the model running we simulate a callback with the quote response
+        cache.publish(`qt_${model.data.quoteId}`, JSON.stringify(quoteResponse));
 
-        // wait for the model to reach a terminal state
-        const result = await resultPromise;
+        // wait for the model to reach quote received
+        result = await resultPromise;
 
         // check we stopped at payeeResolved state
-        expect(result.currentState).toBe('WAITING_FOR_PARTY_ACCEPTANCE');
-        expect(StateMachine.__instance.state).toBe('payeeResolved');
+        expect(result.currentState).toBe('WAITING_FOR_QUOTE_ACCEPTANCE');
+        expect(StateMachine.__instance.state).toBe('quoteReceived');
 
-        // check getParties mojaloop requests method was called with the correct arguments
-        expect(MojaloopRequests.__getParties).toHaveBeenCalledWith(req.to.idType, req.to.idValue, req.to.idSubValue, testFspId);
+        // now run the model again. this should trigger abort as the quote was not accepted
+        result = await model.run({ acceptQuote: false });
+
+        expect(result.currentState).toBe('ABORTED');
+        expect(result.abortedReason).toBe('Quote rejected by backend');
+        expect(StateMachine.__instance.state).toBe('aborted');
     });
 
-    test('halts after resolving payee, resumes and then halts after receiving quote response when AUTO_ACCEPT_PARTY is false and AUTO_ACCEPT_QUOTES is false', async () => {
+    test('should handle unknown state with a meaningful error message', async () => {
+        config.autoAcceptParty = false;
+        config.autoAcceptQuotes = false;
+
+        let model = new Model({
+            cache,
+            logger,
+            metricsClient,
+            ...config,
+        });
+
+        await model.initialize(JSON.parse(JSON.stringify({
+            ...transferRequest,
+            currentState: 'abc'
+        })));
+
+        expect(StateMachine.__instance.state).toBe('abc');
+
+        // start the model running
+        let resultPromise = model.run();
+
+        // wait for the model to reach a terminal state
+        let result = await resultPromise;
+        expect(result).toBe(undefined);
+    });
+
+    test('should handle subsequent put transfer calls incase of aborted transfer', async () => {
         config.autoAcceptParty = false;
         config.autoAcceptQuotes = false;
 
@@ -442,19 +1059,32 @@ describe('outboundModel', () => {
         expect(StateMachine.__instance.state).toBe('payeeResolved');
 
         // now run the model again. this should trigger transition to quote request
-        resultPromise = model.run();
+        resultPromise = model.run({ acceptParty: true });
 
         // now we started the model running we simulate a callback with the quote response
         cache.publish(`qt_${model.data.quoteId}`, JSON.stringify(quoteResponse));
 
-        // wait for the model to reach a terminal state
+        // wait for the model to reach quote received
         result = await resultPromise;
 
         // check we stopped at payeeResolved state
         expect(result.currentState).toBe('WAITING_FOR_QUOTE_ACCEPTANCE');
         expect(StateMachine.__instance.state).toBe('quoteReceived');
-    });
 
+        // now run the model again. this should trigger abort as the quote was not accepted
+        result = await model.run({ acceptQuote: false });
+
+        expect(result.currentState).toBe('ABORTED');
+        expect(result.abortedReason).toBe('Quote rejected by backend');
+        expect(StateMachine.__instance.state).toBe('aborted');
+
+        // now run the model again. this should get the same result as previous one
+        result = await model.run({ acceptQuote: false });
+
+        expect(result.currentState).toBe('ABORTED');
+        expect(result.abortedReason).toBe('Quote rejected by backend');
+        expect(StateMachine.__instance.state).toBe('aborted');
+    });
 
     test('halts and resumes after parties and quotes stages when AUTO_ACCEPT_PARTY is false and AUTO_ACCEPT_QUOTES is false', async () => {
         config.autoAcceptParty = false;
@@ -500,7 +1130,7 @@ describe('outboundModel', () => {
         expect(StateMachine.__instance.state).toBe('payeeResolved');
 
         // now run the model again. this should trigger transition to quote request
-        resultPromise = model.run();
+        resultPromise = model.run({ acceptParty: true });
 
         // now we started the model running we simulate a callback with the quote response
         cache.publish(`qt_${model.data.quoteId}`, JSON.stringify(quoteResponse));
@@ -526,7 +1156,7 @@ describe('outboundModel', () => {
         expect(StateMachine.__instance.state).toBe('quoteReceived');
 
         // now run the model again. this should trigger transition to quote request
-        resultPromise = model.run();
+        resultPromise = model.run({ acceptQuote: true });
 
         // now we started the model running we simulate a callback with the transfer fulfilment
         cache.publish(`tf_${model.data.transferId}`, JSON.stringify(transferFulfil));
@@ -547,26 +1177,26 @@ describe('outboundModel', () => {
         MojaloopRequests.__getParties = jest.fn(() => {
             // simulate a callback with the resolved party
             emitPartyCacheMessage(cache, payeeParty);
-            return Promise.resolve();
+            return Promise.resolve(dummyRequestsModuleResponse);
         });
 
         MojaloopRequests.__postQuotes = jest.fn((postQuotesBody) => {
             // simulate a callback with the quote response
             emitQuoteResponseCacheMessage(cache, postQuotesBody.quoteId, quoteResponse);
-            return Promise.resolve();
+            return Promise.resolve(dummyRequestsModuleResponse);
         });
 
         MojaloopRequests.__postTransfers = jest.fn((postTransfersBody) => {
             //ensure that the `MojaloopRequests.postTransfers` method has been called with the correct arguments
             // set as the destination FSPID, picked up from the header's value `fspiop-source`
-            expect(model.data.quoteResponseSource).toBe(quoteResponse.headers['fspiop-source']);
+            expect(model.data.quoteResponseSource).toBe(quoteResponse.data.headers['fspiop-source']);
             expect(MojaloopRequests.__postTransfers).toHaveBeenCalledTimes(1);
             const payeeFsp = MojaloopRequests.__postTransfers.mock.calls[0][0].payeeFsp;
-            expect(payeeFsp).toEqual(payeeParty.party.partyIdInfo.fspId);
+            expect(payeeFsp).toEqual(payeeParty.body.party.partyIdInfo.fspId);
 
             // simulate a callback with the transfer fulfilment
             emitTransferFulfilCacheMessage(cache, postTransfersBody.transferId, transferFulfil);
-            return Promise.resolve();
+            return Promise.resolve(dummyRequestsModuleResponse);
         });
 
         const model = new Model({
@@ -599,26 +1229,26 @@ describe('outboundModel', () => {
         MojaloopRequests.__getParties = jest.fn(() => {
             // simulate a callback with the resolved party
             emitPartyCacheMessage(cache, payeeParty);
-            return Promise.resolve();
+            return Promise.resolve(dummyRequestsModuleResponse);
         });
 
         MojaloopRequests.__postQuotes = jest.fn((postQuotesBody) => {
             // simulate a callback with the quote response
             emitQuoteResponseCacheMessage(cache, postQuotesBody.quoteId, quoteResponse);
-            return Promise.resolve();
+            return Promise.resolve(dummyRequestsModuleResponse);
         });
 
         MojaloopRequests.__postTransfers = jest.fn((postTransfersBody) => {
             //ensure that the `MojaloopRequests.postTransfers` method has been called with the correct arguments
             // set as the destination FSPID, picked up from the header's value `fspiop-source`
-            expect(model.data.quoteResponseSource).toBe(quoteResponse.headers['fspiop-source']);
+            expect(model.data.quoteResponseSource).toBe(quoteResponse.data.headers['fspiop-source']);
             expect(MojaloopRequests.__postTransfers).toHaveBeenCalledTimes(1);
             const payeeFsp = MojaloopRequests.__postTransfers.mock.calls[0][0].payeeFsp;
-            expect(payeeFsp).toEqual(quoteResponse.headers['fspiop-source']);
+            expect(payeeFsp).toEqual(quoteResponse.data.headers['fspiop-source']);
 
             // simulate a callback with the transfer fulfilment
             emitTransferFulfilCacheMessage(cache, postTransfersBody.transferId, transferFulfil);
-            return Promise.resolve();
+            return Promise.resolve(dummyRequestsModuleResponse);
         });
 
         const model = new Model({
@@ -712,7 +1342,7 @@ describe('outboundModel', () => {
         MojaloopRequests.__getParties = jest.fn(() => {
             // simulate a callback with the resolved party
             cache.publish(genPartyId(payeeParty), JSON.stringify(expectError));
-            return Promise.resolve();
+            return Promise.resolve(dummyRequestsModuleResponse);
         });
 
         const model = new Model({
@@ -727,9 +1357,11 @@ describe('outboundModel', () => {
         expect(StateMachine.__instance.state).toBe('start');
 
         const expectError = {
-            errorInformation: {
-                errorCode: '3204',
-                errorDescription: 'Party not found'
+            body: {
+                errorInformation: {
+                    errorCode: '3204',
+                    errorDescription: 'Party not found'
+                }
             }
         };
 
@@ -742,7 +1374,7 @@ describe('outboundModel', () => {
             expect(err.message.replace(/[ \n]/g,'')).toEqual(errMsg.replace(/[ \n]/g,''));
             expect(err.transferState).toBeTruthy();
             expect(err.transferState.lastError).toBeTruthy();
-            expect(err.transferState.lastError.mojaloopError).toEqual(expectError);
+            expect(err.transferState.lastError.mojaloopError).toEqual(expectError.body);
             expect(err.transferState.lastError.transferState).toBe(undefined);
             return;
         }
@@ -769,13 +1401,13 @@ describe('outboundModel', () => {
         MojaloopRequests.__getParties = jest.fn(() => {
             // simulate a callback with the resolved party
             emitPartyCacheMessage(cache, payeeParty);
-            return Promise.resolve();
+            return Promise.resolve(dummyRequestsModuleResponse);
         });
 
         MojaloopRequests.__postQuotes = jest.fn((postQuotesBody) => {
             // simulate a callback with the quote response
             cache.publish(`qt_${postQuotesBody.quoteId}`, JSON.stringify(expectError));
-            return Promise.resolve();
+            return Promise.resolve(dummyRequestsModuleResponse);
         });
 
         const model = new Model({
@@ -814,9 +1446,11 @@ describe('outboundModel', () => {
         const expectError = {
             type: 'transferError',
             data: {
-                errorInformation: {
-                    errorCode: '4001',
-                    errorDescription: 'Payer FSP insufficient liquidity'
+                body: {
+                    errorInformation: {
+                        errorCode: '4001',
+                        errorDescription: 'Payer FSP insufficient liquidity'
+                    }
                 }
             }
         };
@@ -824,19 +1458,19 @@ describe('outboundModel', () => {
         MojaloopRequests.__getParties = jest.fn(() => {
             // simulate a callback with the resolved party
             emitPartyCacheMessage(cache, payeeParty);
-            return Promise.resolve();
+            return Promise.resolve(dummyRequestsModuleResponse);
         });
 
         MojaloopRequests.__postQuotes = jest.fn((postQuotesBody) => {
             // simulate a callback with the quote response
             emitQuoteResponseCacheMessage(cache, postQuotesBody.quoteId, quoteResponse);
-            return Promise.resolve();
+            return Promise.resolve(dummyRequestsModuleResponse);
         });
 
         MojaloopRequests.__postTransfers = jest.fn((postTransfersBody) => {
             // simulate an error callback with the transfer fulfilment
             cache.publish(`tf_${postTransfersBody.transferId}`, JSON.stringify(expectError));
-            return Promise.resolve();
+            return Promise.resolve(dummyRequestsModuleResponse);
         });
 
         const model = new Model({
@@ -859,7 +1493,7 @@ describe('outboundModel', () => {
             expect(err.message.replace(/[ \n]/g,'')).toEqual(errMsg.replace(/[ \n]/g,''));
             expect(err.transferState).toBeTruthy();
             expect(err.transferState.lastError).toBeTruthy();
-            expect(err.transferState.lastError.mojaloopError).toEqual(expectError.data);
+            expect(err.transferState.lastError.mojaloopError).toEqual(expectError.data.body);
             expect(err.transferState.lastError.transferState).toBe(undefined);
             return;
         }
@@ -902,4 +1536,39 @@ describe('outboundModel', () => {
         expect(metrics).toEqual(expect.stringContaining('mojaloop_connector_outbound_transfer_latency'));
         expect(metrics).toEqual(expect.stringContaining('mojaloop_connector_outbound_party_lookup_latency'));
     });
+
+    test('skips resolving party when to.fspid is specified and skipPartyLookup is truthy', async () => {
+        config.autoAcceptParty = false;
+        config.autoAcceptQuotes = false;
+
+        let model = new Model({
+            cache,
+            logger,
+            metricsClient,
+            ...config,
+        });
+
+        let req = JSON.parse(JSON.stringify(transferRequest));
+        const testFspId = 'TESTDESTFSPID';
+        req.to.fspId = testFspId;
+        req.skipPartyLookup = true;
+
+        await model.initialize(req);
+
+        expect(StateMachine.__instance.state).toBe('start');
+
+        // start the model running
+        let resultPromise = model.run();
+
+        // now we started the model running we simulate a callback with the quote response
+        cache.publish(`qt_${model.data.quoteId}`, JSON.stringify(quoteResponse));
+
+        // wait for the model to reach a terminal state
+        let result = await resultPromise;
+
+        // check we stopped at quoteReceived state
+        expect(result.currentState).toBe('WAITING_FOR_QUOTE_ACCEPTANCE');
+        expect(StateMachine.__instance.state).toBe('quoteReceived');
+    });
+
 });