@mojaloop/sdk-scheme-adapter 12.2.3 → 13.0.1

package/src/lib/model/OutboundTransfersModel.js

@@ -15,17 +15,9 @@ const { uuid } = require('uuidv4');
 const StateMachine = require('javascript-state-machine');
 const { Ilp, MojaloopRequests } = require('@mojaloop/sdk-standard-components');
 const shared = require('./lib/shared');
-const { BackendError } = require('./common');
+const { BackendError, TransferStateEnum } = require('./common');
 const PartiesModel = require('./PartiesModel');
 
-const transferStateEnum = {
-    'WAITING_FOR_PARTY_ACEPTANCE': 'WAITING_FOR_PARTY_ACCEPTANCE',
-    'WAITING_FOR_QUOTE_ACCEPTANCE': 'WAITING_FOR_QUOTE_ACCEPTANCE',
-    'ERROR_OCCURRED': 'ERROR_OCCURRED',
-    'COMPLETED': 'COMPLETED',
-};
-
-
 /**
  *  Models the state machine and operations required for performing an outbound transfer
  */
@@ -42,6 +34,13 @@ class OutboundTransfersModel {
         this._autoAcceptParty = config.autoAcceptParty;
         this._useQuoteSourceFSPAsTransferPayeeFSP = config.useQuoteSourceFSPAsTransferPayeeFSP;
         this._checkIlp = config.checkIlp;
+        this._multiplePartiesResponse = config.multiplePartiesResponse;
+        this._multiplePartiesResponseSeconds = config.multiplePartiesResponseSeconds;
+        this._sendFinalNotificationIfRequested = config.sendFinalNotificationIfRequested;
+
+        if (this._autoAcceptParty && this._multiplePartiesResponse) {
+            throw new Error('Conflicting config options provided: autoAcceptParty and multiplePartiesResponse');
+        }
 
         this._requests = new MojaloopRequests({
             logger: this._logger,
@@ -66,6 +65,36 @@ class OutboundTransfersModel {
             secret: config.ilpSecret,
             logger: this._logger,
         });
+
+        this.metrics = {
+            partyLookupRequests: config.metricsClient.getCounter(
+                'mojaloop_connector_outbound_party_lookup_request_count',
+                'Count of outbound party lookup requests sent'),
+            partyLookupResponses: config.metricsClient.getCounter(
+                'mojaloop_connector_outbound_party_lookup_response_count',
+                'Count of responses received to outbound party lookups'),
+            quoteRequests: config.metricsClient.getCounter(
+                'mojaloop_connector_outbound_quote_request_count',
+                'Count of outbound quote requests sent'),
+            quoteResponses: config.metricsClient.getCounter(
+                'mojaloop_connector_outbound_quote_response_count',
+                'Count of responses received to outbound quote requests'),
+            transferPrepares: config.metricsClient.getCounter(
+                'mojaloop_connector_outbound_transfer_prepare_count',
+                'Count of outbound transfer prepare requests sent'),
+            transferFulfils: config.metricsClient.getCounter(
+                'mojaloop_connector_outbound_transfer_fulfil_response_count',
+                'Count of responses received to outbound transfer prepares'),
+            partyLookupLatency: config.metricsClient.getHistogram(
+                'mojaloop_connector_outbound_party_lookup_latency',
+                'Time taken for a response to a party lookup request to be received'),
+            quoteRequestLatency: config.metricsClient.getHistogram(
+                'mojaloop_connector_outbound_quote_request_latency',
+                'Time taken for a response to a quote request to be received'),
+            transferLatency: config.metricsClient.getHistogram(
+                'mojaloop_connector_outbound_transfer_latency',
+                'Time taken for a response to a transfer prepare to be received')
+        };
     }
 
 
@@ -78,9 +107,11 @@ class OutboundTransfersModel {
             transitions: [
                 { name: 'resolvePayee', from: 'start', to: 'payeeResolved' },
                 { name: 'requestQuote', from: 'payeeResolved', to: 'quoteReceived' },
+                { name: 'requestQuote', from: 'start', to: 'quoteReceived' },
                 { name: 'executeTransfer', from: 'quoteReceived', to: 'succeeded' },
                 { name: 'getTransfer', to: 'succeeded' },
                 { name: 'error', from: '*', to: 'errored' },
+                { name: 'abort', from: '*', to: 'aborted' },
             ],
             methods: {
                 onTransition: this._handleTransition.bind(this),
@@ -129,6 +160,13 @@ class OutboundTransfersModel {
             this.data.initiatedTimestamp = new Date().toISOString();
         }
 
+        if(!this.data.hasOwnProperty('direction')) {
+            this.data.direction = 'OUTBOUND';
+        }
+        if(this.data.skipPartyLookup && typeof(this.data.to.fspId) === undefined) {
+            throw new Error('fspId of to party must be specific id when skipPartyLookup is truthy');
+        }
+
         this._initStateMachine(this.data.currentState);
     }
 
@@ -146,6 +184,9 @@ class OutboundTransfersModel {
 
             case 'resolvePayee':
                 // resolve the payee
+                if (this._multiplePartiesResponse) {
+                    return this._resolveBatchPayees();
+                }
                 return this._resolvePayee();
 
             case 'requestQuote':
@@ -159,6 +200,11 @@ class OutboundTransfersModel {
                 // prepare a transfer and wait for fulfillment
                 return this._executeTransfer();
 
+            case 'abort':
+                this._logger.log('State machine is aborting transfer');
+                this.data.abortedReason = args[0];
+                break;
+
             case 'error':
                 this._logger.log(`State machine is erroring with error: ${util.inspect(args)}`);
                 this.data.lastError = args[0] || new Error('unspecified error');
@@ -185,20 +231,26 @@ class OutboundTransfersModel {
                 subId: this.data.to.idSubValue
             });
 
+            let latencyTimerDone;
+
             // hook up a subscriber to handle response messages
             const subId = await this._cache.subscribe(payeeKey, (cn, msg, subId) => {
                 try {
-                    let payee = JSON.parse(msg);
+                    if(latencyTimerDone) {
+                        latencyTimerDone();
+                    }
+                    this.metrics.partyLookupResponses.inc();
 
-                    if(payee.errorInformation) {
+                    this.data.getPartiesResponse = JSON.parse(msg);
+                    if(this.data.getPartiesResponse.body && this.data.getPartiesResponse.body.errorInformation) {
                         // this is an error response to our GET /parties request
-                        const err = new BackendError(`Got an error response resolving party: ${util.inspect(payee, { depth: Infinity })}`, 500);
-                        err.mojaloopError = payee;
-
+                        const err = new BackendError(`Got an error response resolving party: ${util.inspect(this.data.getPartiesResponse.body, { depth: Infinity })}`, 500);
+                        err.mojaloopError = this.data.getPartiesResponse.body;
                         // cancel the timeout handler
                         clearTimeout(timeout);
                         return reject(err);
                     }
+                    let payee = this.data.getPartiesResponse.body;
 
                     if(!payee.party) {
                         // we should never get a non-error response without a party, but just in case...
@@ -273,18 +325,27 @@ class OutboundTransfersModel {
                     this._logger.log(`Error unsubscribing (in timeout handler) ${payeeKey} ${subId}: ${e.stack || util.inspect(e)}`);
                 });
 
+                if(latencyTimerDone) {
+                    latencyTimerDone();
+                }
+
                 return reject(err);
             }, this._requestProcessingTimeoutSeconds * 1000);
 
             // now we have a timeout handler and a cache subscriber hooked up we can fire off
             // a GET /parties request to the switch
             try {
+                latencyTimerDone = this.metrics.partyLookupLatency.startTimer();
                 const res = await this._requests.getParties(this.data.to.idType, this.data.to.idValue,
                     this.data.to.idSubValue, this.data.to.fspId);
+
+                this.data.getPartiesRequest = res.originalRequest;
+
+                this.metrics.partyLookupRequests.inc();
                 this._logger.push({ peer: res }).log('Party lookup sent to peer');
             }
             catch(err) {
-                // cancel the timout and unsubscribe before rejecting the promise
+                // cancel the timeout and unsubscribe before rejecting the promise
                 clearTimeout(timeout);
 
                 // we dont really care if the unsubscribe fails but we should log it regardless
@@ -297,6 +358,107 @@ class OutboundTransfersModel {
         });
     }
 
+    /**
+     * Resolves multiple payees.
+     * Starts the payee resolution process by sending a GET /parties request to the switch;
+     * then waits for a specified number of seconds and resolve payees with responses from the cache.
+     */
+    _resolveBatchPayees() {
+        // eslint-disable-next-line no-async-promise-executor
+        return new Promise(async (resolve, reject) => {
+            let latencyTimerDone;
+            // hook up a timer to handle response messages
+            // const timer = setTimeout((cn, msg, subId) => {
+            const payeeResolver = (msg) => {
+                this.data.getPartiesResponse = JSON.parse(msg);
+
+                if(this.data.getPartiesResponse.body.errorInformation) {
+                    // this is an error response to our GET /parties request
+                    const err = new BackendError(`Got an error response resolving party: ${util.inspect(this.data.getPartiesResponse.body, { depth: Infinity })}`, 500);
+                    err.mojaloopError = this.data.getPartiesResponse.body;
+                    throw err;
+                }
+                let payee = this.data.getPartiesResponse.body;
+
+                if(!payee.party) {
+                    // we should never get a non-error response without a party, but just in case...
+                    // cancel the timeout handler
+                    throw new Error(`Resolved payee has no party object: ${util.inspect(payee)}`);
+                }
+                payee = payee.party;
+                // check we got the right payee and info we need
+                if(payee.partyIdInfo.partyIdType !== this.data.to.idType) {
+                    throw new Error(`Expecting resolved payee party IdType to be ${this.data.to.idType} but got ${payee.partyIdInfo.partyIdType}`);
+                }
+                if(payee.partyIdInfo.partyIdentifier !== this.data.to.idValue) {
+                    throw new Error(`Expecting resolved payee party identifier to be ${this.data.to.idValue} but got ${payee.partyIdInfo.partyIdentifier}`);
+                }
+                if(payee.partyIdInfo.partySubIdOrType !== this.data.to.idSubValue) {
+                    throw new Error(`Expecting resolved payee party subTypeId to be ${this.data.to.idSubValue} but got ${payee.partyIdInfo.partySubIdOrType}`);
+                }
+                if(!payee.partyIdInfo.fspId) {
+                    throw new Error(`Expecting resolved payee party to have an FSPID: ${util.inspect(payee.partyIdInfo)}`);
+                }
+                // now we got the payee, add the details to our data so we can use it
+                // in the quote request
+                const to = {};
+                to.fspId = payee.partyIdInfo.fspId;
+                if(payee.partyIdInfo.extensionList) {
+                    to.extensionList  = payee.partyIdInfo.extensionList.extension;
+                }
+                if(payee.personalInfo) {
+                    if(payee.personalInfo.complexName) {
+                        to.firstName = payee.personalInfo.complexName.firstName || this.data.to.firstName;
+                        to.middleName = payee.personalInfo.complexName.middleName || this.data.to.middleName;
+                        to.lastName = payee.personalInfo.complexName.lastName || this.data.to.lastName;
+                    }
+                    to.dateOfBirth = payee.personalInfo.dateOfBirth;
+                }
+                return to;
+            };
+            // listen for resolution events on the payee idType and idValue
+            // const payeeKey = `${this.data.to.idType}_${this.data.to.idValue}`
+            //     + (this.data.to.idSubValue ? `_${this.data.to.idSubValue}` : '');
+            const payeeKey = PartiesModel.channelName({
+                type: this.data.to.idType,
+                id: this.data.to.idValue,
+                subId: this.data.to.idSubValue
+            });
+            const timer = setTimeout(async () => {
+                if(latencyTimerDone) {
+                    latencyTimerDone();
+                }
+                this.metrics.partyLookupResponses.inc();
+                let payeeList;
+                try {
+                    payeeList = await this._cache.members(payeeKey);
+                } catch (e) {
+                    return reject(e);
+                }
+                if (!payeeList.length) {
+                    return reject(new BackendError(`Timeout resolving payees for transfer ${this.data.transferId}`, 504));
+                }
+                this._logger.push({ payeeList }).log('Payees resolved');
+                this.data.to = payeeList.map(payeeResolver);
+                resolve();
+            }, this._multiplePartiesResponseSeconds * 1000);
+            // now we have a timeout handler we can fire off
+            // a GET /parties request to the switch
+            try {
+                latencyTimerDone = this.metrics.partyLookupLatency.startTimer();
+                const res = await this._requests.getParties(this.data.to.idType, this.data.to.idValue,
+                    this.data.to.idSubValue);
+                this.data.getPartiesRequest = res.originalRequest;
+                this.metrics.partyLookupRequests.inc();
+                this._logger.push({ peer: res }).log('Party lookup sent to peer');
+            }
+            catch(err) {
+                // cancel the timer before rejecting the promise
+                clearTimeout(timer);
+                return reject(err);
+            }
+        });
+    }
 
     /**
      * Requests a quote
@@ -312,10 +474,16 @@ class OutboundTransfersModel {
 
             // listen for events on the quoteId
             const quoteKey = `qt_${quote.quoteId}`;
+            let latencyTimerDone;
 
             // hook up a subscriber to handle response messages
             const subId = await this._cache.subscribe(quoteKey, (cn, msg, subId) => {
                 try {
+                    if(latencyTimerDone) {
+                        latencyTimerDone();
+                    }
+                    this.metrics.quoteResponses.inc();
+
                     let error;
                     let message = JSON.parse(msg);
 
@@ -351,12 +519,13 @@ class OutboundTransfersModel {
                         return reject(error);
                     }
 
-                    const quoteResponseBody = message.data;
-                    const quoteResponseHeaders = message.headers;
-                    this._logger.push({ quoteResponseBody }).log('Quote response received');
+                    this.data.quoteResponse = {
+                        headers: message.data.headers,
+                        body: message.data.body
+                    };
+                    this._logger.push({ quoteResponse: this.data.quoteResponse.body }).log('Quote response received');
 
-                    this.data.quoteResponse = quoteResponseBody;
-                    this.data.quoteResponseSource = quoteResponseHeaders['fspiop-source'];
+                    this.data.quoteResponseSource = this.data.quoteResponse.headers['fspiop-source'];
 
                     return resolve(quote);
                 }
@@ -374,13 +543,22 @@ class OutboundTransfersModel {
                     this._logger.log(`Error unsubscribing (in timeout handler) ${quoteKey} ${subId}: ${e.stack || util.inspect(e)}`);
                 });
 
+                if(latencyTimerDone) {
+                    latencyTimerDone();
+                }
+
                 return reject(err);
             }, this._requestProcessingTimeoutSeconds * 1000);
 
             // now we have a timeout handler and a cache subscriber hooked up we can fire off
             // a POST /quotes request to the switch
             try {
+                latencyTimerDone = this.metrics.quoteRequestLatency.startTimer();
                 const res = await this._requests.postQuotes(quote, this.data.to.fspId);
+
+                this.data.quoteRequest = res.originalRequest;
+
+                this.metrics.quoteRequests.inc();
                 this._logger.push({ res }).log('Quote request sent to peer');
             }
             catch(err) {
@@ -459,12 +637,20 @@ class OutboundTransfersModel {
             // listen for events on the transferId
             const transferKey = `tf_${this.data.transferId}`;
 
+            let latencyTimerDone;
+
             const subId = await this._cache.subscribe(transferKey, async (cn, msg, subId) => {
                 try {
+                    if(latencyTimerDone) {
+                        latencyTimerDone();
+                    }
+
                     let error;
                     let message = JSON.parse(msg);
 
                     if (message.type === 'transferFulfil') {
+                        this.metrics.transferFulfils.inc();
+
                         if (this._rejectExpiredTransferFulfils) {
                             const now = new Date().toISOString();
                             if (now > prepare.expiration) {
@@ -474,10 +660,10 @@ class OutboundTransfersModel {
                             }
                         }
                     } else if (message.type === 'transferError') {
-                        error = new BackendError(`Got an error response preparing transfer: ${util.inspect(message.data, { depth: Infinity })}`, 500);
-                        error.mojaloopError = message.data;
+                        error = new BackendError(`Got an error response preparing transfer: ${util.inspect(message.data.body, { depth: Infinity })}`, 500);
+                        error.mojaloopError = message.data.body;
                     } else {
-                        this._logger.push({ message }).log(`Ignoring cache notification for transfer ${transferKey}. Uknokwn message type ${message.type}.`);
+                        this._logger.push({ message }).log(`Ignoring cache notification for transfer ${transferKey}. Unknown message type ${message.type}.`);
                         return;
                     }
 
@@ -494,14 +680,29 @@ class OutboundTransfersModel {
                     }
 
                     const fulfil = message.data;
-                    this._logger.push({ fulfil }).log('Transfer fulfil received');
+                    this._logger.push({ fulfil: fulfil.body }).log('Transfer fulfil received');
                     this.data.fulfil = fulfil;
-
-                    if(this._checkIlp && !this._ilp.validateFulfil(fulfil.fulfilment, this.data.quoteResponse.condition)) {
+                    if(this._checkIlp && !this._ilp.validateFulfil(fulfil.body.fulfilment, this.data.quoteResponse.body.condition)) {
                         throw new Error('Invalid fulfilment received from peer DFSP.');
                     }
-
-                    return resolve(fulfil);
+                    if(this._sendFinalNotificationIfRequested && fulfil.body.transferState === 'RESERVED') {
+                        // we need to send a PATCH notification back to say we have committed the transfer.
+                        // Note that this is normally a switch only responsibility but the capability is
+                        // implemented here to support testing use cases where the mojaloop-connector is
+                        // acting in a peer-to-peer scenario and it is desirable for the other peer to
+                        // receive this notification.
+                        // Note that the transfer is considered committed as far as this (payer) side is concerned
+                        // we will use the current server time as committed timestamp.
+                        const patchNotification = {
+                            completedTimestamp: (new Date()).toISOString(),
+                            transferState: 'COMMITTED',
+                        };
+                        const res = this._requests.patchTransfers(this.data.transferId,
+                            patchNotification, this.data.quoteResponseSource);
+                        this.data.patch = res.originalRequest;
+                        this._logger.log(`PATCH final notification sent to peer for transfer ${this.data.transferId}`);
+                    }
+                    return resolve(fulfil.body);
                 }
                 catch(err) {
                     return reject(err);
@@ -517,17 +718,26 @@ class OutboundTransfersModel {
                     this._logger.log(`Error unsubscribing (in timeout handler) ${transferKey} ${subId}: ${e.stack || util.inspect(e)}`);
                 });
 
+                if(latencyTimerDone) {
+                    latencyTimerDone();
+                }
+
                 return reject(err);
             }, this._requestProcessingTimeoutSeconds * 1000);
 
             // now we have a timeout handler and a cache subscriber hooked up we can fire off
             // a POST /transfers request to the switch
             try {
+                latencyTimerDone = this.metrics.transferLatency.startTimer();
                 const res = await this._requests.postTransfers(prepare, this.data.quoteResponseSource);
+
+                this.data.prepare = res.originalRequest;
+
+                this.metrics.transferPrepares.inc();
                 this._logger.push({ res }).log('Transfer prepare sent to peer');
             }
             catch(err) {
-                // cancel the timout and unsubscribe before rejecting the promise
+                // cancel the timeout and unsubscribe before rejecting the promise
                 clearTimeout(timeout);
 
                 // we dont really care if the unsubscribe fails but we should log it regardless
@@ -553,32 +763,26 @@ class OutboundTransfersModel {
                 try {
                     let error;
                     let message = JSON.parse(msg);
-
                     if (message.type === 'transferError') {
-                        error = new BackendError(`Got an error response retrieving transfer: ${util.inspect(message.data, { depth: Infinity })}`, 500);
-                        error.mojaloopError = message.data;
+                        error = new BackendError(`Got an error response retrieving transfer: ${util.inspect(message.data.body, { depth: Infinity })}`, 500);
+                        error.mojaloopError = message.data.body;
                     } else if (message.type !== 'transferFulfil') {
                         this._logger.push({ message }).log(`Ignoring cache notification for transfer ${transferKey}. Uknokwn message type ${message.type}.`);
                         return;
                     }
-
                     // cancel the timeout handler
                     clearTimeout(timeout);
-
                     // stop listening for transfer fulfil messages
                     this._cache.unsubscribe(transferKey, subId).catch(e => {
                         this._logger.log(`Error unsubscribing (in callback) ${transferKey} ${subId}: ${e.stack || util.inspect(e)}`);
                     });
-
                     if (error) {
                         return reject(error);
                     }
-
                     const fulfil = message.data;
-                    this._logger.push({ fulfil }).log('Transfer fulfil received');
+                    this._logger.push({ fulfil: fulfil.body }).log('Transfer fulfil received');
                     this.data.fulfil = fulfil;
-
-                    return resolve(this.data);
+                    return resolve(this.data.fulfil);
                 }
                 catch(err) {
                     return reject(err);
@@ -633,11 +837,11 @@ class OutboundTransfersModel {
                 // rather than the original request. In Forex cases we may have requested
                 // a RECEIVE amount in a currency we cannot send. FXP should always give us
                 // a quote response with transferAmount in the correct currency.
-                currency: this.data.quoteResponse.transferAmount.currency,
-                amount: this.data.quoteResponse.transferAmount.amount
+                currency: this.data.quoteResponse.body.transferAmount.currency,
+                amount: this.data.quoteResponse.body.transferAmount.amount
             },
-            ilpPacket: this.data.quoteResponse.ilpPacket,
-            condition: this.data.quoteResponse.condition,
+            ilpPacket: this.data.quoteResponse.body.ilpPacket,
+            condition: this.data.quoteResponse.body.condition,
             expiration: this._getExpirationTimestamp()
         };
 
@@ -681,24 +885,28 @@ class OutboundTransfersModel {
 
         switch(this.data.currentState) {
             case 'payeeResolved':
-                resp.currentState = transferStateEnum.WAITING_FOR_PARTY_ACEPTANCE;
+                resp.currentState = TransferStateEnum.WAITING_FOR_PARTY_ACCEPTANCE;
                 break;
 
             case 'quoteReceived':
-                resp.currentState = transferStateEnum.WAITING_FOR_QUOTE_ACCEPTANCE;
+                resp.currentState = TransferStateEnum.WAITING_FOR_QUOTE_ACCEPTANCE;
                 break;
 
             case 'succeeded':
-                resp.currentState = transferStateEnum.COMPLETED;
+                resp.currentState = TransferStateEnum.COMPLETED;
+                break;
+
+            case 'aborted':
+                resp.currentState = TransferStateEnum.ABORTED;
                 break;
 
             case 'errored':
-                resp.currentState = transferStateEnum.ERROR_OCCURRED;
+                resp.currentState = TransferStateEnum.ERROR_OCCURRED;
                 break;
 
             default:
                 this._logger.log(`Transfer model response being returned from an unexpected state: ${this.data.currentState}. Returning ERROR_OCCURRED state`);
-                resp.currentState = transferStateEnum.ERROR_OCCURRED;
+                resp.currentState = TransferStateEnum.ERROR_OCCURRED;
                 break;
         }
 
@@ -712,7 +920,7 @@ class OutboundTransfersModel {
     async _save() {
         try {
             this.data.currentState = this.stateMachine.state;
-            const res = await this._cache.set(`transferModel_${this.data.transferId}`, this.data);
+            const res = await this._cache.set(`transferModel_out_${this.data.transferId}`, this.data);
             this._logger.push({ res }).log('Persisted transfer model in cache');
         }
         catch(err) {
@@ -729,7 +937,8 @@ class OutboundTransfersModel {
      */
     async load(transferId) {
         try {
-            const data = await this._cache.get(`transferModel_${transferId}`);
+            const data = await this._cache.get(`transferModel_out_${transferId}`);
+
             if(!data) {
                 throw new Error(`No cached data found for transferId: ${transferId}`);
             }
@@ -745,12 +954,39 @@ class OutboundTransfersModel {
 
     /**
      * Returns a promise that resolves when the state machine has reached a terminal state
+     *
+     * @param mergeDate {object} - an object to merge with the model state (data) before running the state machine
      */
-    async run() {
+    async run(mergeData) {
         try {
+            // if we were passed a mergeData object...
+            // merge it with our existing state, overwriting any existing matching root level keys
+            if(mergeData) {
+                // first remove any merge keys that we do not want to allow to be changed
+                // note that we could do this in the swagger also. this is to put a responsibility
+                // on this model to defend itself.
+                const permittedMergeKeys = ['acceptParty', 'acceptQuote', 'amount', 'to'];
+                Object.keys(mergeData).forEach(k => {
+                    if(permittedMergeKeys.indexOf(k) === -1) {
+                        delete mergeData[k];
+                    }
+                });
+                this.data = {
+                    ...this.data,
+                    ...mergeData,
+                };
+            }
             // run transitions based on incoming state
             switch(this.data.currentState) {
                 case 'start':
+                    // first transition is to resolvePayee
+                    if(typeof(this.data.to.fspId) !== 'undefined' && this.data.skipPartyLookup) {
+                        // we already have the payee DFSP and we have bee asked to skip party resolution
+                        this._logger.log(`Skipping payee resolution for transfer ${this.data.transferId} as to.fspId was provided and skipPartyLookup is truthy`);
+                        this.data.currentState = 'payeeResolved';
+                        break;
+                    }
+
                     // next transition is to resolvePayee
                     await this.stateMachine.resolvePayee();
                     this._logger.log(`Payee resolved for transfer ${this.data.transferId}`);
@@ -763,6 +999,13 @@ class OutboundTransfersModel {
                     break;
 
                 case 'payeeResolved':
+                    if(!this._autoAcceptParty && !this.data.acceptParty && !this.data.skipPartyLookup) {
+                        // resuming after a party resolution halt, backend did not accept the party.
+                        await this.stateMachine.abort('Payee rejected by backend');
+                        await this._save();
+                        return this.getResponse();
+                    }
+
                     // next transition is to requestQuote
                     await this.stateMachine.requestQuote();
                     this._logger.log(`Quote received for transfer ${this.data.transferId}`);
@@ -775,6 +1018,13 @@ class OutboundTransfersModel {
                     break;
 
                 case 'quoteReceived':
+                    if(!this._autoAcceptQuotes && !this.data.acceptQuote) {
+                        // resuming after a party resolution halt, backend did not accept the party.
+                        await this.stateMachine.abort('Quote rejected by backend');
+                        await this._save();
+                        return this.getResponse();
+                    }
+
                     // next transition is executeTransfer
                     await this.stateMachine.executeTransfer();
                     this._logger.log(`Transfer ${this.data.transferId} has been completed`);
@@ -796,9 +1046,21 @@ class OutboundTransfersModel {
                     await this._save();
                     this._logger.log('State machine in errored state');
                     return;
+
+                case 'aborted':
+                    // stopped in aborted state
+                    await this._save();
+                    this._logger.log('State machine in aborted state');
+                    return this.getResponse();
+
+                default:
+                    // The state is not handled here, throwing an error to avoid an infinite recursion of this function
+                    await this._save();
+                    this._logger.error(`State machine in unhandled(${this.data.currentState}) state`);
+                    return;
             }
 
-            // now call ourslves recursively to deal with the next transition
+            // now call ourselves recursively to deal with the next transition
             this._logger.log(`Transfer model state machine transition completed in state: ${this.stateMachine.state}. Recusring to handle next transition.`);
             return this.run();
         }

package/src/lib/model/PartiesModel.js

@@ -58,7 +58,7 @@ function argsValidation({ type, id, subId }) {
     }
 }
 
-// generate model 
+// generate model
 const PartiesModel = Async2SyncModel.generate({
     modelName: 'PartiesModel',
     channelNameMethod: channelName,