@mojaloop/sdk-scheme-adapter 12.3.0 → 13.0.0

package/src/OutboundServer/api.yaml

@@ -1002,6 +1002,12 @@ components:
           $ref: '#/components/schemas/extensionListEmptiable'
         transferRequestExtensions:
           $ref: '#/components/schemas/extensionListEmptiable'
+        skipPartyLookup:
+          description: >-
+            Set to true if supplying an FSPID for the payee party and no party
+            resolution is needed. This may be useful is a previous party
+            resolution has been performed.
+          type: boolean
     CorrelationId:
       title: CorrelationId
       type: string
@@ -1273,8 +1279,24 @@ components:
           $ref: '#/components/schemas/transferStatus'
         quoteId:
           $ref: '#/components/schemas/CorrelationId'
+        getPartiesResponse:
+          type: object
+          required:
+            - body
+          properties:
+            body:
+              type: object
+            headers:
+              type: object
         quoteResponse:
-          $ref: '#/components/schemas/QuotesIDPutResponse'
+          type: object
+          required:
+            - body
+          properties:
+            body:
+              $ref: '#/components/schemas/QuotesIDPutResponse'
+            headers:
+              type: object
         quoteResponseSource:
           type: string
           description: >
@@ -1283,7 +1305,14 @@ components:
             account in the case of a FOREX transfer. i.e. it may be a FOREX
             gateway.
         fulfil:
-          $ref: '#/components/schemas/TransfersIDPutResponse'
+          type: object
+          required:
+            - body
+          properties:
+            body:
+              $ref: '#/components/schemas/TransfersIDPutResponse'
+            headers:
+              type: object
         lastError:
           description: >
             Object representing the last error to occur during a transfer
@@ -1291,6 +1320,12 @@ components:
             entity in the scheme or an object representing other types of error
             e.g. exceptions that may occur inside the scheme adapter.
           $ref: '#/components/schemas/transferError'
+        skipPartyLookup:
+          description: >-
+            Set to true if supplying an FSPID for the payee party and no party
+            resolution is needed. This may be useful is a previous party
+            resolution has been performed.
+          type: boolean
     errorResponse:
       type: object
       properties:
@@ -1321,7 +1356,14 @@ components:
         currentState:
           $ref: '#/components/schemas/transferStatus'
         fulfil:
-          $ref: '#/components/schemas/TransfersIDPutResponse'
+          type: object
+          required:
+            - body
+          properties:
+            body:
+              $ref: '#/components/schemas/TransfersIDPutResponse'
+            headers:
+              type: object
     transferContinuationAcceptParty:
       type: object
       required:
@@ -1993,6 +2035,15 @@ components:
           $ref: '#/components/schemas/accountsCreationState'
         lastError:
           $ref: '#/components/schemas/transferError'
+        postAccountsResponse:
+          type: object
+          required:
+            - body
+          properties:
+            body:
+              type: object
+            headers:
+              type: object
     errorAccountsResponse:
       allOf:
         - $ref: '#/components/schemas/errorResponse'

package/src/OutboundServer/api_interfaces/openapi.d.ts

@@ -633,6 +633,8 @@ export interface components {
       note?: components["schemas"]["Note"];
       quoteRequestExtensions?: components["schemas"]["extensionListEmptiable"];
       transferRequestExtensions?: components["schemas"]["extensionListEmptiable"];
+      /** Set to true if supplying an FSPID for the payee party and no party resolution is needed. This may be useful is a previous party resolution has been performed. */
+      skipPartyLookup?: boolean;
     };
     /** Identifier that correlates all messages of the same sequence. The API data type UUID (Universally Unique Identifier) is a JSON String in canonical format, conforming to [RFC 4122](https://tools.ietf.org/html/rfc4122), that is restricted by a regular expression for interoperability reasons. A UUID is always 36 characters long, 32 hexadecimal symbols and 4 dashes (‘-‘). */
     CorrelationId: string;
@@ -728,12 +730,24 @@ export interface components {
       note?: components["schemas"]["Note"];
       currentState?: components["schemas"]["transferStatus"];
       quoteId?: components["schemas"]["CorrelationId"];
-      quoteResponse?: components["schemas"]["QuotesIDPutResponse"];
+      getPartiesResponse?: {
+        body: { [key: string]: unknown };
+        headers?: { [key: string]: unknown };
+      };
+      quoteResponse?: {
+        body: components["schemas"]["QuotesIDPutResponse"];
+        headers?: { [key: string]: unknown };
+      };
       /** FSPID of the entity that supplied the quote response. This may not be the same as the FSPID of the entity which owns the end user account in the case of a FOREX transfer. i.e. it may be a FOREX gateway. */
       quoteResponseSource?: string;
-      fulfil?: components["schemas"]["TransfersIDPutResponse"];
+      fulfil?: {
+        body: components["schemas"]["TransfersIDPutResponse"];
+        headers?: { [key: string]: unknown };
+      };
       /** Object representing the last error to occur during a transfer process. This may be a Mojaloop API error returned from another entity in the scheme or an object representing other types of error e.g. exceptions that may occur inside the scheme adapter. */
       lastError?: components["schemas"]["transferError"];
+      /** Set to true if supplying an FSPID for the payee party and no party resolution is needed. This may be useful is a previous party resolution has been performed. */
+      skipPartyLookup?: boolean;
     };
     errorResponse: {
       /** Error code as string. */
@@ -747,7 +761,10 @@ export interface components {
     transferStatusResponse: {
       transferId: components["schemas"]["CorrelationId"];
       currentState: components["schemas"]["transferStatus"];
-      fulfil: components["schemas"]["TransfersIDPutResponse"];
+      fulfil: {
+        body: components["schemas"]["TransfersIDPutResponse"];
+        headers?: { [key: string]: unknown };
+      };
     };
     transferContinuationAcceptParty: {
       acceptParty: true;
@@ -1011,6 +1028,10 @@ export interface components {
       response?: components["schemas"]["accountCreationStatus"];
       currentState?: components["schemas"]["accountsCreationState"];
       lastError?: components["schemas"]["transferError"];
+      postAccountsResponse?: {
+        body: { [key: string]: unknown };
+        headers?: { [key: string]: unknown };
+      };
     };
     errorAccountsResponse: components["schemas"]["errorResponse"] & {
       executionState: components["schemas"]["accountsResponse"];

package/src/OutboundServer/api_template/components/schemas/accountsResponse.yaml

@@ -13,3 +13,12 @@ properties:
     $ref: ./accountsCreationState.yaml
   lastError:
     $ref: ./transferError.yaml
+  postAccountsResponse:
+    type: object
+    required:
+      - body
+    properties:
+      body:
+        type: object
+      headers:
+        type: object

package/src/OutboundServer/api_template/components/schemas/transferRequest.yaml

@@ -35,3 +35,6 @@ properties:
     $ref: ./extensionListEmptiable.yaml
   transferRequestExtensions:
     $ref: ./extensionListEmptiable.yaml
+  skipPartyLookup:
+    description: Set to true if supplying an FSPID for the payee party and no party resolution is needed. This may be useful is a previous party resolution has been performed.
+    type: boolean

package/src/OutboundServer/api_template/components/schemas/transferResponse.yaml

@@ -39,8 +39,24 @@ properties:
   quoteId:
     $ref: >-
       ../../../../../node_modules/@mojaloop/api-snippets/fspiop/v1_1/openapi3/components/schemas/CorrelationId.yaml
+  getPartiesResponse:
+    type: object
+    required:
+      - body
+    properties:
+      body:
+        type: object
+      headers:
+        type: object
   quoteResponse:
-    $ref: ./quote.yaml
+    type: object
+    required:
+      - body
+    properties:
+      body:
+        $ref: './quote.yaml'
+      headers:
+        type: object
   quoteResponseSource:
     type: string
     description: >
@@ -48,7 +64,14 @@ properties:
       same as the FSPID of the entity which owns the end user account in the
       case of a FOREX transfer. i.e. it may be a FOREX gateway.
   fulfil:
-    $ref: ./transferFulfilment.yaml
+      type: object
+      required:
+        - body
+      properties:
+        body:
+          $ref: ./transferFulfilment.yaml
+        headers:
+          type: object
   lastError:
     description: >
       Object representing the last error to occur during a transfer process.
@@ -56,3 +79,6 @@ properties:
       scheme or an object representing other types of error e.g. exceptions that
       may occur inside the scheme adapter.
     $ref: ./transferError.yaml
+  skipPartyLookup:
+    description: Set to true if supplying an FSPID for the payee party and no party resolution is needed. This may be useful is a previous party resolution has been performed.
+    type: boolean

package/src/OutboundServer/api_template/components/schemas/transferStatusResponse.yaml

@@ -10,4 +10,11 @@ properties:
   currentState:
     $ref: ./transferStatus.yaml
   fulfil:
-    $ref: ./transferFulfilment.yaml
+      type: object
+      required:
+        - body
+      properties:
+        body:
+          $ref: ./transferFulfilment.yaml
+        headers:
+          type: object

package/src/OutboundServer/handlers.js

@@ -182,7 +182,7 @@ const putTransfers = async (ctx) => {
         // load the transfer model from cache and start it running again
         await model.load(ctx.state.path.params.transferId);
 
-        const response = await model.run();
+        const response = await model.run(ctx.request.body);
 
         // return the result
         ctx.response.status = 200;

package/src/config.js

@@ -182,5 +182,5 @@ module.exports = {
     // the `transactionId` to retrieve the quote from cache
     allowDifferentTransferTransactionId: env.get('ALLOW_DIFFERENT_TRANSFER_TRANSACTION_ID').default('false').asBool(),
 
-    pm4mlEnabled: env.get('PM4ML_ENABLED').default('false').asBool()
+    pm4mlEnabled: env.get('PM4ML_ENABLED').default('false').asBool(),
 };

package/src/lib/model/AccountsModel.js

@@ -133,20 +133,23 @@ class AccountsModel {
 
 
     async _executeCreateAccountsRequest(request) {
+        const accountRequest = request;
+
         // eslint-disable-next-line no-async-promise-executor
         return new Promise(async (resolve, reject) => {
-            const requestKey = `ac_${request.requestId}`;
+            const requestKey = `ac_${accountRequest.requestId}`;
 
             const subId = await this._cache.subscribe(requestKey, async (cn, msg, subId) => {
                 try {
                     let error;
-                    let message = JSON.parse(msg);
+                    const message = JSON.parse(msg);
+                    this._data.postAccountsResponse = message.data;
 
                     if (message.type === 'accountsCreationErrorResponse') {
-                        error = new BackendError(`Got an error response creating accounts: ${util.inspect(message.data)}`, 500);
-                        error.mojaloopError = message.data;
+                        error = new BackendError(`Got an error response creating accounts: ${util.inspect(this._data.postAccountsResponse.body)}`, 500);
+                        error.mojaloopError = this._data.postAccountsResponse.body;
                     } else if (message.type !== 'accountsCreationSuccessfulResponse') {
-                        this._logger.push({ message }).log(
+                        this._logger.push(util.inspect(this._data.postAccountsResponse)).log(
                             `Ignoring cache notification for request ${requestKey}. ` +
                             `Unknown message type ${message.type}.`
                         );
@@ -167,7 +170,7 @@ class AccountsModel {
                         return reject(error);
                     }
 
-                    const response = message.data;
+                    const response = this._data.postAccountsResponse;
                     this._logger.push({ response }).log('Account creation response received');
                     return resolve(response);
                 }
@@ -178,7 +181,7 @@ class AccountsModel {
 
             // set up a timeout for the request
             const timeout = setTimeout(() => {
-                const err = new BackendError(`Timeout waiting for response to account creation request ${request.requestId}`, 504);
+                const err = new BackendError(`Timeout waiting for response to account creation request ${accountRequest.requestId}`, 504);
 
                 // we dont really care if the unsubscribe fails but we should log it regardless
                 this._cache.unsubscribe(requestKey, subId).catch(e => {
@@ -191,7 +194,7 @@ class AccountsModel {
             // now we have a timeout handler and a cache subscriber hooked up we can fire off
             // a POST /participants request to the switch
             try {
-                const res = await this._requests.postParticipants(request);
+                const res = await this._requests.postParticipants(accountRequest);
                 this._logger.push({ res }).log('Account creation request sent to peer');
             }
             catch(err) {
@@ -218,11 +221,11 @@ class AccountsModel {
     }
 
     _buildClientResponse(response) {
-        return response.partyList.map(party => ({
+        return response.body.partyList.map(party => ({
             idType: party.partyId.partyIdType,
             idValue: party.partyId.partyIdentifier,
             idSubValue: party.partyId.partySubIdOrType,
-            ...!response.currency && {
+            ...!response.body.currency && {
                 error: {
                     statusCode: Errors.MojaloopApiErrorCodes.CLIENT_ERROR.code,
                     message: 'Provided currency not supported',
@@ -295,7 +298,6 @@ class AccountsModel {
                 resp.currentState = stateEnum.ERROR_OCCURRED;
                 break;
         }
-
         return resp;
     }
 

package/src/lib/model/InboundTransfersModel.js

@@ -10,6 +10,7 @@
 
 'use strict';
 
+const util = require('util');
 
 const {
     BackendRequests,
@@ -21,6 +22,7 @@ const {
     Errors,
 } = require('@mojaloop/sdk-standard-components');
 const shared = require('./lib/shared');
+const { TransferStateEnum } = require('./common');
 
 /**
  *  Models the operations required for performing inbound transfers
@@ -70,6 +72,12 @@ class InboundTransfersModel {
         });
     }
 
+    updateStateWithError(err) {
+        this.data.lastError = err;
+        this.data.currentState = TransferStateEnum.ERROR_OCCURRED;
+        return this._save();
+    }
+
     /**
      * Queries the backend API for the specified party and makes a callback to the originator with the result
      */
@@ -162,7 +170,32 @@ class InboundTransfersModel {
      * Asks the backend for a response to an incoming quote request and makes a callback to the originator with
      * the result
      */
-    async quoteRequest(quoteRequest, sourceFspId) {
+    async quoteRequest(request, sourceFspId) {
+        const quoteRequest = request.body;
+
+        // keep track of our state.
+        // note that instances of this model typically only live as long as it takes to
+        // handle an incoming request and send a response asynchronously, but we hold onto
+        // some state across async ops
+
+        this.data = {
+            // transferId: this follows the slightly dodgy assumption that transferId will be same as this transactionId.
+            // so far this has held in moja implementations but may not always be the case. regardless, future FSPIOP API
+            // versions MUST deal with this cleanly so we can expect to eliminate this assumption at some point.
+            transferId: quoteRequest.transactionId,
+            direction: 'INBOUND',
+            quoteRequest: {
+                headers: request.headers,
+                body: request.body
+            },
+            currentState: TransferStateEnum.QUOTE_REQUEST_RECEIVED,
+            initiatedTimestamp: new Date().toISOString(),
+        };
+
+        // persist the transfer record in the cache. if we crash after this at least we will
+        // have a record of the request in the cache.
+        await this._save();
+
         try {
             const internalForm = shared.mojaloopQuoteRequestToInternal(quoteRequest);
 
@@ -189,19 +222,24 @@ class InboundTransfersModel {
             mojaloopResponse.condition = condition;
 
             // now store the fulfilment and the quote data against the quoteId in our cache
-            await this._cache.set(`quote_${quoteRequest.transactionId}`, {
+            this.data.quote = {
                 request: quoteRequest,
                 internalRequest: internalForm,
                 response: response,
                 mojaloopResponse: mojaloopResponse,
                 fulfilment: fulfilment
-            });
-
-            // now store the quoteResponse data against the quoteId in our cache to be sent as a response to GET /quotes/{ID}
-            await this._cache.set(`quoteResponse_${quoteRequest.quoteId}`, mojaloopResponse);
+            };
+            await this._save();
 
             // make a callback to the source fsp with the quote response
-            return this._mojaloopRequests.putQuotes(quoteRequest.quoteId, mojaloopResponse, sourceFspId);
+            const res = await this._mojaloopRequests.putQuotes(quoteRequest.quoteId, mojaloopResponse, sourceFspId);
+            this.data.quoteResponse = {
+                headers: res.originalRequest.headers,
+                body: res.originalRequest.body,
+            };
+            this.data.currentState = TransferStateEnum.WAITING_FOR_QUOTE_ACCEPTANCE;
+            await this._save();
+            return res;
         }
         catch(err) {
             this._logger.push({ err }).log('Error in quoteRequest');
@@ -257,7 +295,7 @@ class InboundTransfersModel {
                 return 'No response from backend';
             }
 
-            // project our internal quote reponse into mojaloop quote response form
+            // project our internal quote response into mojaloop quote response form
             const mojaloopResponse = shared.internalTransactionRequestResponseToMojaloop(response);
 
             // make a callback to the source fsp with the quote response
@@ -277,25 +315,36 @@ class InboundTransfersModel {
      * Validates an incoming transfer prepare request and makes a callback to the originator with
      * the result
      */
-    async prepareTransfer(prepareRequest, sourceFspId) {
+    async prepareTransfer(request, sourceFspId) {
+        const prepareRequest = request.body;
         try {
             // retrieve our quote data
-            let quote;
-
             if (this._allowDifferentTransferTransactionId) {
                 const transactionId = this._ilp.getTransactionObject(prepareRequest.ilpPacket).transactionId;
-                quote = await this._cache.get(`quote_${transactionId}`);
+                this.data = await this._load(transactionId);
             } else {
-                quote = await this._cache.get(`quote_${prepareRequest.transferId}`);
+                this.data = await this._load(prepareRequest.transferId);
             }
 
-            if(!quote) {
+            const quote = this.data.quote;
+
+            if(!this.data || !quote) {
+                // If using the sdk-scheme-adapter in place of the deprecated `mojaloop-connector`
+                // make sure this is false. Scenarios that use `mojaloop-connector`
+                // absolutely requires a previous quote before allowing a transfer to proceed.
+                // This is a different to the a typical mojaloop sdk-scheme-adapter setup which allows this as an option.
+
                 // Check whether to allow transfers without a previous quote.
                 if(!this._allowTransferWithoutQuote) {
                     throw new Error(`Corresponding quote not found for transfer ${prepareRequest.transferId}`);
                 }
             }
 
+            // persist our state so we have a record if we crash during processing the prepare
+            this.data.prepare = request;
+            this.data.currentState = TransferStateEnum.PREPARE_RECEIVED;
+            await this._save();
+
             // Calculate or retrieve fulfilment and condition
             let fulfilment = null;
             let condition = null;
@@ -313,13 +362,13 @@ class InboundTransfersModel {
                 throw new Error(`ILP condition in transfer prepare for ${prepareRequest.transferId} does not match quote`);
             }
 
-
-            if (quote && this._rejectTransfersOnExpiredQuotes) {
+            if (this._rejectTransfersOnExpiredQuotes) {
                 const now = new Date().toISOString();
                 const expiration = quote.mojaloopResponse.expiration;
                 if (now > expiration) {
                     const error = Errors.MojaloopApiErrorObjectFromCode(Errors.MojaloopApiErrorCodes.QUOTE_EXPIRED);
                     this._logger.error(`Error in prepareTransfer: quote expired for transfer ${prepareRequest.transferId}, system time=${now} > quote time=${expiration}`);
+                    await this.updateStateWithError(error);
                     return this._mojaloopRequests.putTransfersError(prepareRequest.transferId, error, sourceFspId);
                 }
             }
@@ -336,6 +385,7 @@ class InboundTransfersModel {
             }
 
             this._logger.log(`Transfer accepted by backend returning homeTransactionId: ${response.homeTransactionId} for mojaloop transferId: ${prepareRequest.transferId}`);
+            this.data.homeTransactionId = response.homeTransactionId;
 
             // create a  mojaloop transfer fulfil response
             const mojaloopResponse = {
@@ -350,10 +400,16 @@ class InboundTransfersModel {
             };
 
             // make a callback to the source fsp with the transfer fulfilment
-            return this._mojaloopRequests.putTransfers(prepareRequest.transferId, mojaloopResponse,
+            const res = await this._mojaloopRequests.putTransfers(prepareRequest.transferId, mojaloopResponse,
                 sourceFspId);
-        }
-        catch(err) {
+            this.data.fulfil = {
+                headers: res.originalRequest.headers,
+                body: res.originalRequest.body,
+            };
+            this.data.currentState = this._reserveNotification ? TransferStateEnum.RESERVED : TransferStateEnum.COMPLETED;
+            await this._save();
+            return res;
+        } catch(err) {
             this._logger.push({ err }).log('Error in prepareTransfer');
             const mojaloopError = await this._handleError(err);
             this._logger.push({ mojaloopError }).log(`Sending error response to ${sourceFspId}`);
@@ -717,22 +773,108 @@ class InboundTransfersModel {
     */
     async sendNotificationToPayee(body, transferId) {
         try {
-            const res = await this._backendRequests.putTransfersNotification(body, transferId);
+            // load any cached state for this transfer e.g. quote request/response etc...
+            this.data = await this._load(transferId);
+
+            // if we didnt have anything cached, start from scratch
+            if(!this.data) {
+                this.data = {};
+            }
+
+            // tag the final notification body on to the state
+            this.data.finalNotification = body;
+
+            if(body.transferState === 'COMMITTED') {
+                // if the transfer was successful in the switch, set the overall transfer state to COMPLETED
+                this.data.currentState = TransferStateEnum.COMPLETED;
+            }
+            else {
+                // if the final notification has anything other than COMMITTED as the final state, set an error
+                // in the transfer state.
+                this.data.currentState == TransferStateEnum.ERROR_OCCURED;
+                this.data.lastError = 'Final notification state not COMMITTED';
+            }
+
+            await this._save();
+
+            const res = await this._backendRequests.putTransfersNotification(this.data, transferId);
             return res;
         } catch (err) {
-            this._logger.push({ err }).log('Error in sendNotificationToPayee');
+            this._logger.push({ err }).log('Error notifying backend of final transfer state');
         }
     }
 
-    async _handleError(err, mojaloopErrorCode = Errors.MojaloopApiErrorCodes.INTERNAL_SERVER_ERROR) {
+    async _handleError(err) {
+        // by default use a generic server error
+        let mojaloopError = (new Errors.MojaloopFSPIOPError(err, null, null, Errors.MojaloopApiErrorCodes.INTERNAL_SERVER_ERROR)).toApiErrorObject();
         if(err instanceof HTTPResponseError) {
+            // this is an http response error e.g. from calling DFSP backend
             const e = err.getData();
             if(e.res && e.res.data) {
-                mojaloopErrorCode = Errors.MojaloopApiErrorCodeFromCode(`${e.res.data.statusCode}`);
+                // look for a standard mojaloop error that matches the statusCode
+                let mojaloopErrorCode = Errors.MojaloopApiErrorCodeFromCode(`${e.res.data.statusCode}`);
+                let errorDescription = e.res.data.message;
+                if(mojaloopErrorCode) {
+                    // use the standard mojaloop error object
+                    mojaloopError = (new Errors.MojaloopFSPIOPError(err, null, null, mojaloopErrorCode)).toApiErrorObject();
+                    if(errorDescription) {
+                        // if the error has a description, use that instead of the default mojaloop description
+                        // note that the mojaloop API spec allows any string up to 128 utf8 characters to be sent
+                        // in the errorDescription field.
+                        mojaloopError.errorInformation.errorDescription = errorDescription;
+                    }
+                }
+                else {
+                    // this is a custom error, so construct a mojaloop spec body
+                    mojaloopError = {
+                        errorInformation: {
+                            errorCode: e.res.data.statusCode,
+                            errorDescription: e.res.data.message,
+                        }
+                    };
+                }
             }
         }
+        if(this.data) {
+            //we have persisted state so update that with this error
+            this.data.lastError = {
+                originalError: err.stack || util.inspect(err),
+                mojaloopError: mojaloopError,
+            };
+            this.data.currentState = TransferStateEnum.ERROR_OCCURRED;
+            await this._save();
+        }
+        return mojaloopError;
+    }
 
-        return new Errors.MojaloopFSPIOPError(err, null, null, mojaloopErrorCode).toApiErrorObject();
+    /**
+     * Persists the model state to cache for reinstantiation at a later point
+     */
+    async _save() {
+        try {
+            const res = await this._cache.set(`transferModel_in_${this.data.transferId}`, this.data);
+            this._logger.push({ res }).log('Persisted transfer model in cache');
+        }
+        catch(err) {
+            this._logger.push({ err }).log('Error saving transfer model');
+            throw err;
+        }
+    }
+
+    /**
+     * Loads a transfer model from cache for resumption of the transfer process
+     *
+     * @param transferId {string} - UUID transferId of the model to load from cache
+     */
+    async _load(transferId) {
+        try {
+            const data = await this._cache.get(`transferModel_in_${transferId}`);
+            return data;
+        }
+        catch(err) {
+            this._logger.push({ err }).log('Error loading transfer model');
+            throw err;
+        }
     }
 }
 

package/src/lib/model/OutboundRequestToPayModel.js

@@ -155,17 +155,16 @@ class OutboundRequestToPayModel {
             // 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(payee.errorInformation) {
+                    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(payee)}`, 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...