account-lookup-service 17.8.0-snapshot.9 → 17.9.0-snapshot.0

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [17.8.0](https://github.com/mojaloop/account-lookup-service/compare/v17.7.1...v17.8.0) (2025-04-03)
+
+
+### Features
+
+* **csi-1266:** reset party mappings in inter-scheme scenario ([#541](https://github.com/mojaloop/account-lookup-service/issues/541)) ([279fac6](https://github.com/mojaloop/account-lookup-service/commit/279fac6bff5e9a30c0583e1bcfb724787590516c))
+
+### [17.7.1](https://github.com/mojaloop/account-lookup-service/compare/v17.7.0...v17.7.1) (2025-03-27)
+
+
+### Chore
+
+* **csi-1248:** update transform-lib, others ([#543](https://github.com/mojaloop/account-lookup-service/issues/543)) ([7a0a5c4](https://github.com/mojaloop/account-lookup-service/commit/7a0a5c402e8f8f28661540ea5982b1ac9a97a8dd))
+
 ## [17.7.0](https://github.com/mojaloop/account-lookup-service/compare/v17.6.0...v17.7.0) (2025-03-26)
 
 

package/docker/mock-proxy/src/server.ts

@@ -38,24 +38,26 @@ app.get('/health', (req: Request, res: Response) => {
 app.get('/parties/:type/:id', (req: Request, res: Response) => {
   const { type, id } = req.params;
   const headers = hubCbHeaders(req.headers);
-  console.log('parties request details:', { type, id, headers, CL_HOST, CL_PORT });
+  const statusCode = detectStatusCode(req);
+  console.log('parties request details:', { type, id, headers, CL_HOST, CL_PORT, statusCode });
 
   // todo: reply to CL with party info
 
   res
     .set(headers)
-    .status(202)
+    .status(statusCode)
     .json({ success: true });
 });
 
 app.put('/parties/:type/:id/error', (req: Request, res: Response) => {
   const { type, id } = req.params;
   const headers = dfspCbHeaders(req.headers);
-  console.log('parties put error request details:', { type, id, headers, CL_HOST, CL_PORT });
+  const statusCode = detectStatusCode(req);
+  console.log('parties put error request details:', { type, id, headers, CL_HOST, CL_PORT, statusCode });
 
   res
     .set(headers)
-    .status(200)
+    .status(statusCode)
     .json({ success: true });
 });
 
@@ -92,3 +94,10 @@ const httpsServer = http.createServer(app);
 httpsServer.listen(PROXY_PORT, () => {
   console.log(`Mock proxyAdapter "${PROXY_NAME}" is running on port ${PROXY_PORT}...`);
 });
+
+const X_RESPONSE_STATUS_HEADER = 'x-response-status';
+
+const detectStatusCode = (req: Request) =>
+  typeof req.headers[X_RESPONSE_STATUS_HEADER] === 'string'
+    ? parseInt(req.headers[X_RESPONSE_STATUS_HEADER], 10)
+    : (req.method === 'GET' ? 202 : 200);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "account-lookup-service",
   "description": "Account Lookup Service is used to validate Party and Participant lookups.",
-  "version": "17.8.0-snapshot.9",
+  "version": "17.9.0-snapshot.0",
   "license": "Apache-2.0",
   "author": "ModusBox",
   "contributors": [
@@ -92,21 +92,21 @@
     "@hapi/vision": "7.0.3",
     "@mojaloop/central-services-error-handling": "13.0.7",
     "@mojaloop/central-services-health": "15.0.4",
-    "@mojaloop/central-services-logger": "11.8.0",
+    "@mojaloop/central-services-logger": "11.8.1",
     "@mojaloop/central-services-metrics": "12.5.0",
-    "@mojaloop/central-services-shared": "18.23.1",
+    "@mojaloop/central-services-shared": "18.23.2",
     "@mojaloop/central-services-stream": "11.5.2",
     "@mojaloop/database-lib": "11.1.4",
     "@mojaloop/event-sdk": "14.4.0",
-    "@mojaloop/inter-scheme-proxy-cache-lib": "2.4.0",
-    "@mojaloop/ml-schema-transformer-lib": "2.7.0",
+    "@mojaloop/inter-scheme-proxy-cache-lib": "2.5.0",
+    "@mojaloop/ml-schema-transformer-lib": "2.7.1",
     "@mojaloop/sdk-standard-components": "19.11.3-snapshot.0",
     "@now-ims/hapi-now-auth": "2.1.0",
     "ajv": "8.17.1",
     "ajv-keywords": "5.1.0",
     "blipp": "4.0.2",
     "commander": "13.1.0",
-    "cron": "4.1.1",
+    "cron": "4.1.4",
     "fast-safe-stringify": "^2.1.1",
     "hapi-auth-bearer-token": "8.0.0",
     "joi": "17.13.3",

package/src/constants.js

@@ -29,12 +29,14 @@ const { API_TYPES } = require('@mojaloop/central-services-shared').Util.Hapi
 
 const ERROR_MESSAGES = Object.freeze({
   emptyFilteredPartyList: 'Empty oracle partyList, filtered based on callbackEndpointType',
+  externalPartyError: 'External party error', // todo: think better message
   failedToCacheSendToProxiesList: 'Failed to cache sendToProxiesList',
   noDiscoveryRequestsForwarded: 'No discovery requests forwarded to participants',
   sourceFspNotFound: 'Requester FSP not found',
   partyDestinationFspNotFound: 'Destination FSP not found',
   partyProxyNotFound: 'Proxy not found',
-  proxyConnectionError: 'Proxy connection error - no successful requests sent to proxies'
+  proxyConnectionError: 'Proxy connection error - no successful requests sent to proxies',
+  noSuccessfulProxyDiscoveryResponses: 'No successful proxy discovery responses'
 })
 
 const HANDLER_TYPES = Object.freeze({

package/src/domain/parties/putParties.js

@@ -97,15 +97,7 @@ const putPartiesErrorByTypeAndID = async (headers, params, payload, dataUri, spa
   let fspiopError
 
   try {
-    const needDiscovery = await service.handleRequest()
-    if (needDiscovery) {
-      const getPartiesService = new services.GetPartiesService(deps, inputs)
-      await getPartiesService.triggerInterSchemeDiscoveryFlow(
-        services.GetPartiesService.headersWithoutDestination(headers)
-      )
-      // think, if we need to start the whole processing with getPartiesService.handleRequest() ?
-    }
-
+    await service.handleRequest()
     logger.info('putPartiesErrorByTypeAndID is done')
     histTimerEnd({ success: true })
   } catch (error) {

package/src/domain/parties/services/BasePartiesService.js

@@ -30,6 +30,7 @@ const { Enum } = require('@mojaloop/central-services-shared')
 const { decodePayload } = require('@mojaloop/central-services-shared').Util.StreamingProtocol
 const { initStepState } = require('../../../lib/util')
 const { createCallbackHeaders } = require('../../../lib/headers')
+const { ERROR_MESSAGES } = require('../../../constants')
 
 const { FspEndpointTypes, FspEndpointTemplates } = Enum.EndPoints
 const { Headers, RestMethods } = Enum.Http
@@ -100,16 +101,17 @@ class BasePartiesService {
   get state () { return this.#state }
 
   async handleError (error) {
-    const { headers, params } = this.inputs
+    const { params } = this.inputs
     const log = this.log.child({ method: 'handleError' })
     try {
       log.error('error in processing parties request: ', error)
       const fspiopError = ErrorHandler.Factory.reformatFSPIOPError(error)
-      const errorInfo = await this.deps.partiesUtils.makePutPartiesErrorPayload(this.deps.config, fspiopError, headers, params)
+      const callbackHeaders = BasePartiesService.createErrorCallbackHeaders(this.inputs.headers, params)
+      const errorInfo = await this.deps.partiesUtils.makePutPartiesErrorPayload(this.deps.config, fspiopError, callbackHeaders, params)
 
       await this.sendErrorCallback({
         errorInfo,
-        headers: BasePartiesService.createErrorCallbackHeaders(headers, params),
+        headers: callbackHeaders,
         params
       })
       log.info('handleError in done')
@@ -122,13 +124,39 @@ class BasePartiesService {
   }
 
   async validateParticipant (participantId) {
-    this.stepInProgress('validateParticipant')
-    return this.deps.participant.validateParticipant(participantId)
+    try {
+      this.stepInProgress('validateParticipant')
+      return this.deps.participant.validateParticipant(participantId)
+    } catch (err) {
+      this.log.warn(`error in validateParticipant ${participantId}: `, err)
+      return null
+    }
+  }
+
+  async identifyDestinationForCallback () {
+    this.stepInProgress('identifyDestinationForCallback')
+    const { destination } = this.state
+
+    const schemeParticipant = await this.validateParticipant(destination)
+    if (schemeParticipant) {
+      this.state.requester = destination
+      return
+    }
+
+    const proxyName = this.state.proxyEnabled && await this.deps.proxyCache.lookupProxyByDfspId(destination)
+    if (proxyName) {
+      this.state.requester = proxyName
+      return
+    }
+
+    const errMessage = ERROR_MESSAGES.partyDestinationFspNotFound
+    this.log.warn(`${errMessage} and no proxy`, { destination })
+    throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.DESTINATION_FSP_ERROR, errMessage)
   }
 
   async sendErrorCallback ({ errorInfo, headers, params }) {
     this.stepInProgress('sendErrorCallback')
-    const sendTo = this.state.requester || this.state.source
+    const sendTo = this.state.requester || headers[Headers.FSPIOP.DESTINATION] /* || this.state.source */
     const endpointType = this.deps.partiesUtils.errorPartyCbType(params.SubId)
 
     await this.deps.participant.sendErrorToParticipant(
@@ -143,6 +171,7 @@ class BasePartiesService {
   }
 
   async removeProxyGetPartiesTimeoutCache (alsReq) {
+    this.stepInProgress('removeProxyGetPartiesTimeoutCache')
     const isRemoved = await this.deps.proxyCache.removeProxyGetPartiesTimeout(alsReq, this.state.proxy)
     this.log.debug('removeProxyGetPartiesTimeoutCache is done', { isRemoved, alsReq })
     return isRemoved
@@ -153,6 +182,16 @@ class BasePartiesService {
     return ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
   }
 
+  createFspiopPartyNotFoundError (errMessage, log = this.log) {
+    log.warn(errMessage)
+    return ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.PARTY_NOT_FOUND, errMessage)
+  }
+
+  createFspiopServiceUnavailableError (errMessage, log = this.log) {
+    log.warn(errMessage)
+    return ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.SERVICE_CURRENTLY_UNAVAILABLE, errMessage)
+  }
+
   stepInProgress (stepName) {
     this.log.debug('step is in progress', { stepName })
     this.state.stepState?.inProgress(stepName)
@@ -192,8 +231,8 @@ class BasePartiesService {
     }
   }
 
-  static createErrorCallbackHeaders (headers, params) {
-    return createCallbackHeaders({
+  static createErrorCallbackHeaders (headers, params, overrideDestination = '') {
+    const cbHeaders = createCallbackHeaders({
       requestHeaders: headers,
       partyIdType: params.Type,
       partyIdentifier: params.ID,
@@ -201,6 +240,10 @@ class BasePartiesService {
         ? FspEndpointTemplates.PARTIES_SUB_ID_PUT_ERROR
         : FspEndpointTemplates.PARTIES_PUT_ERROR
     })
+    if (overrideDestination) {
+      cbHeaders[Headers.FSPIOP.DESTINATION] = overrideDestination
+    }
+    return cbHeaders
   }
 
   static createHubErrorCallbackHeaders (hubName, destination) {

package/src/domain/parties/services/GetPartiesService.js

@@ -148,10 +148,13 @@ class GetPartiesService extends BasePartiesService {
     }
 
     const alsReq = await this.#setProxyListToCache(proxyNames, source, params)
-    const sentList = await this.#sendOutProxyRequests({ proxyNames, alsReq, headers, params })
+    const { sentList, wasLast } = await this.#sendOutProxyRequests({ proxyNames, alsReq, headers, params })
     if (sentList.length === 0) {
       throw super.createFspiopIdNotFoundError(ERROR_MESSAGES.proxyConnectionError, log)
     }
+    if (wasLast) {
+      throw super.createFspiopIdNotFoundError(ERROR_MESSAGES.noSuccessfulProxyDiscoveryResponses, log)
+    }
 
     log.info('triggerInterSchemeDiscoveryFlow is done:', { sentList, alsReq })
     return sentList
@@ -233,7 +236,7 @@ class GetPartiesService extends BasePartiesService {
   async #sendPartyNotFoundErrorCallback (headers) {
     const { params } = this.inputs
     const callbackHeaders = GetPartiesService.createErrorCallbackHeaders(headers, params)
-    const fspiopError = super.createFspiopIdNotFoundError('No proxy found to start inter-scheme discovery flow')
+    const fspiopError = super.createFspiopPartyNotFoundError('No proxy found to start inter-scheme discovery flow')
     const errorInfo = await this.deps.partiesUtils.makePutPartiesErrorPayload(
       this.deps.config, fspiopError, callbackHeaders, params
     )
@@ -262,21 +265,23 @@ class GetPartiesService extends BasePartiesService {
   async #sendOutProxyRequests ({ proxyNames, alsReq, headers, params }) {
     this.stepInProgress('#sendOutProxyRequests')
     const sentList = []
+    let wasLast = false // if any failed proxy request was last
 
     const sendProxyRequest = (sendTo) => this.#forwardGetPartiesRequest({ sendTo, headers, params })
       .then(() => { sentList.push(sendTo) })
       .catch(err => {
         this.log.error(`error in sending request to proxy ${sendTo}: `, err)
-        this.log.verbose(`remove proxy ${sendTo} from proxyCache...`)
+        this.log.verbose(`removing proxy ${sendTo} from proxyCache...`)
         return this.deps.proxyCache.receivedErrorResponse(alsReq, sendTo)
       })
+      .then((isLast) => { wasLast = isLast })
       .catch(err => {
         this.log.error(`failed to remove proxy ${sendTo} from proxyCache: `, err)
       })
     await Promise.all(proxyNames.map(sendProxyRequest))
 
-    this.log.verbose('#sendOutProxyRequests is done:', { sentList, proxyNames })
-    return sentList
+    this.log.verbose('#sendOutProxyRequests is done:', { sentList, wasLast, proxyNames })
+    return { sentList, wasLast }
   }
 
   async #getFilteredProxyList (proxy) {

package/src/domain/parties/services/PutPartiesErrorService.js

@@ -25,35 +25,36 @@
  --------------
  ******/
 
-const ErrorHandler = require('@mojaloop/central-services-error-handling')
-const { ERROR_MESSAGES } = require('../../../constants')
 const BasePartiesService = require('./BasePartiesService')
+const { ERROR_MESSAGES } = require('../../../constants')
 
 class PutPartiesErrorService extends BasePartiesService {
-  /** @returns {Promise<true | undefined>} - If true, need to trigger inter-scheme discovery. */
   async handleRequest () {
     if (this.state.proxyEnabled && this.state.proxy) {
       const alsReq = this.deps.partiesUtils.alsRequestDto(this.state.destination, this.inputs.params) // or source?
-      const isPending = await this.deps.proxyCache.isPendingCallback(alsReq)
-
-      if (!isPending) {
-        // not initial inter-scheme discovery case. Cleanup oracle and trigger inter-scheme discovery
-        this.log.warn('Need to cleanup oracle and trigger new inter-scheme discovery flow')
-        await this.cleanupOracle()
-        await this.removeProxyGetPartiesTimeoutCache(alsReq)
-        return true // need to trigger inter-scheme discovery
-      }
-
-      const isLast = await this.checkLastProxyCallback(alsReq)
-      if (!isLast) {
-        this.log.verbose('putPartiesErrorByTypeAndID proxy callback was processed')
-        return
+      const isInterSchemeDiscoveryCase = await this.deps.proxyCache.isPendingCallback(alsReq)
+
+      if (isInterSchemeDiscoveryCase) {
+        const isLast = await this.checkLastProxyCallback(alsReq)
+        if (!isLast) {
+          this.log.verbose('proxy error callback was processed (not last)')
+          return
+        }
+      } else {
+        const schemeParticipant = await this.validateParticipant(this.state.destination)
+        if (schemeParticipant) {
+          this.log.info('Need to cleanup oracle and forward SERVICE_CURRENTLY_UNAVAILABLE error')
+          await this.cleanupOracle()
+          await this.removeProxyGetPartiesTimeoutCache(alsReq)
+          await this.forwardServiceUnavailableErrorCallback()
+          return
+        }
       }
     }
 
-    await this.identifyDestinationForErrorCallback()
+    await super.identifyDestinationForCallback()
     await this.sendErrorCallbackToParticipant()
-    this.log.info('putPartiesByTypeAndID is done')
+    this.log.info('handleRequest is done')
   }
 
   async cleanupOracle () {
@@ -72,32 +73,26 @@ class PutPartiesErrorService extends BasePartiesService {
     return isLast
   }
 
-  async identifyDestinationForErrorCallback () {
-    this.stepInProgress('identifyDestinationForErrorCallback')
-    const { destination } = this.state
-    const schemeParticipant = await super.validateParticipant(destination)
-    if (schemeParticipant) {
-      this.state.requester = destination
-      return
-    }
-
-    this.stepInProgress('lookupProxyDestination-4')
-    const proxyName = this.state.proxyEnabled && await this.deps.proxyCache.lookupProxyByDfspId(destination)
-    if (proxyName) {
-      this.state.requester = proxyName
-      return
-    }
-
-    const errMessage = ERROR_MESSAGES.partyDestinationFspNotFound
-    this.log.warn(errMessage, { destination })
-    throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.DESTINATION_FSP_ERROR, errMessage)
-  }
-
   async sendErrorCallbackToParticipant () {
     const { headers, params, dataUri } = this.inputs
     const errorInfo = PutPartiesErrorService.decodeDataUriPayload(dataUri)
     return super.sendErrorCallback({ errorInfo, headers, params })
   }
+
+  async forwardServiceUnavailableErrorCallback () {
+    this.stepInProgress('forwardServiceUnavailableErrorCallback')
+    const { headers, params } = this.inputs
+    const error = super.createFspiopServiceUnavailableError(ERROR_MESSAGES.externalPartyError)
+    const callbackHeaders = BasePartiesService.createErrorCallbackHeaders(headers, params, this.state.destination)
+    const errorInfo = await this.deps.partiesUtils.makePutPartiesErrorPayload(this.deps.config, error, callbackHeaders, params)
+
+    await super.sendErrorCallback({
+      errorInfo,
+      headers: callbackHeaders,
+      params
+    })
+    this.log.verbose('#forwardServiceUnavailableErrorCallback is done', { callbackHeaders, errorInfo })
+  }
 }
 
 module.exports = PutPartiesErrorService

package/src/domain/parties/services/PutPartiesService.js

@@ -25,7 +25,6 @@
  --------------
  ******/
 
-const ErrorHandler = require('@mojaloop/central-services-error-handling')
 const { ERROR_MESSAGES } = require('../../../constants')
 const BasePartiesService = require('./BasePartiesService')
 
@@ -40,7 +39,7 @@ class PutPartiesService extends BasePartiesService {
     if (proxy) {
       await this.checkProxySuccessResponse()
     }
-    await this.identifyDestinationForSuccessCallback()
+    await this.identifyDestinationForCallback()
     await this.sendSuccessCallback()
   }
 
@@ -85,25 +84,6 @@ class PutPartiesService extends BasePartiesService {
     }
   }
 
-  async identifyDestinationForSuccessCallback () {
-    const { destination } = this.state
-    this.stepInProgress('identifyDestinationForSuccessCallback')
-    const destinationParticipant = await super.validateParticipant(destination)
-    if (destinationParticipant) {
-      this.state.requester = destinationParticipant.name
-      return
-    }
-
-    const proxyName = this.state.proxyEnabled && await this.deps.proxyCache.lookupProxyByDfspId(destination)
-    if (!proxyName) {
-      const errMessage = ERROR_MESSAGES.partyDestinationFspNotFound
-      this.log.warn(`${errMessage} and no proxy`, { destination })
-      throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.DESTINATION_FSP_ERROR, errMessage)
-    }
-
-    this.state.requester = proxyName
-  }
-
   async sendSuccessCallback () {
     const { headers, params, dataUri } = this.inputs
     const sendTo = this.state.requester

package/src/domain/parties/services/TimeoutPartiesService.js

@@ -52,7 +52,7 @@ class TimeoutPartiesService extends PutPartiesErrorService {
     const { errorInfo, headers, params } = await this.prepareErrorInformation()
     this.#spanAuditStart(errorInfo)
 
-    await this.identifyDestinationForErrorCallback()
+    await this.identifyDestinationForCallback()
     return super.sendErrorCallback({ errorInfo, headers, params })
   }
 

package/src/handlers/index.js

@@ -38,12 +38,12 @@ const { HANDLER_TYPES } = require('../constants')
 const Config = require('../lib/config')
 const log = require('../lib').logger.child('ALS-timeout-handler')
 
-process.on('uncaughtExceptionMonitor', (err) => {
-  log.error(`uncaughtException: ${err?.message}`, err)
+process.on('uncaughtException', (err, origin) => {
+  log.error(`uncaughtException event [origin: ${origin}]: `, err)
   process.exit(2)
 })
 process.on('unhandledRejection', (err) => {
-  log.error(`unhandledRejection: ${err?.message}`, err)
+  log.error('unhandledRejection event: ', err)
   process.exit(3)
 })
 

package/src/index.js

@@ -24,7 +24,8 @@
 
 'use strict'
 
-process.env.HTTP_DEFAULT_RETRY_DELAY = process.env.HTTP_DEFAULT_RETRY_DELAY || '0'
+process.env.HTTP_DEFAULT_RETRIES = process.env.HTTP_DEFAULT_RETRIES || '0'
+// todo: think better way to avoid reties
 
 const Server = require('./server')
 const PJson = require('../package.json')

package/src/lib/util.js

@@ -97,8 +97,8 @@ const rethrowDatabaseError = (error) => {
 }
 
 const countFspiopError = (error, options) => {
-  options.loggerOverride = logger
-  rethrow.countFspiopError(error, options)
+  options.loggerOverride = options?.log || logger
+  return rethrow.countFspiopError(error, options)
 }
 
 /**

package/src/models/oracle/facade.js

@@ -29,18 +29,19 @@
 const Mustache = require('mustache')
 const request = require('@mojaloop/central-services-shared').Util.Request
 const Enums = require('@mojaloop/central-services-shared').Enum
-const Logger = require('@mojaloop/central-services-logger')
 const ErrorHandler = require('@mojaloop/central-services-error-handling')
 const Metrics = require('@mojaloop/central-services-metrics')
 
 const Config = require('../../lib/config')
-const oracleEndpointCached = require('../oracle/oracleEndpointCached')
+const { logger } = require('../../lib')
+const { countFspiopError } = require('../../lib/util')
 const { hubNameRegex } = require('../../lib/util').hubNameConfig
+const oracleEndpointCached = require('../oracle/oracleEndpointCached')
+
+const { Headers, RestMethods, ReturnCodes } = Enums.Http
 
 /**
- * @function oracleRequest
- *
- * @description This sends a request to the oracles that are registered to the ALS
+ * Sends a request to the oracles that are registered to the ALS
  *
  * @param {object} headers - incoming http request headers
  * @param {string} method - incoming http request method
@@ -49,130 +50,134 @@ const { hubNameRegex } = require('../../lib/util').hubNameConfig
  * @param {object} payload - payload of the request being sent out
  * @param {object} assertPendingAcquire - flag to check DB pool pending acquire limit
  *
- * @returns {object} returns the response from the oracle
+ * @returns {object} - response from the oracle
  */
-exports.oracleRequest = async (headers, method, params = {}, query = {}, payload = undefined, cache, assertPendingAcquire) => {
+const oracleRequest = async (headers, method, params = {}, query = {}, payload = undefined, cache, assertPendingAcquire) => {
+  const operation = oracleRequest.name
+  const log = logger.child({ component: operation, params })
+  let step = 'start'
+
   try {
-    let url
-    const partyIdType = params.Type
-    const partyIdentifier = params.ID
-    const currency = (payload && payload.currency) ? payload.currency : (query && query.currency) ? query.currency : undefined
-    const partySubIdOrType = (params && params.SubId) ? params.SubId : (query && query.partySubIdOrType) ? query.partySubIdOrType : undefined
-    const isGetRequest = method.toUpperCase() === Enums.Http.RestMethods.GET
-    const isDeleteRequest = method.toUpperCase() === Enums.Http.RestMethods.DELETE
+    const source = headers[Headers.FSPIOP.SOURCE]
+    const destination = headers[Headers.FSPIOP.DESTINATION] || Config.HUB_NAME
+    const partySubIdOrType = params?.SubId || query?.partySubIdOrType
+    log.info('oracleRequest start...', { method, source, destination })
 
-    if (currency && partySubIdOrType && isGetRequest) {
-      url = await _getOracleEndpointByTypeCurrencyAndSubId(partyIdType, partyIdentifier, currency, partySubIdOrType, assertPendingAcquire)
-    } else if (currency && isGetRequest) {
-      url = await _getOracleEndpointByTypeAndCurrency(partyIdType, partyIdentifier, currency, assertPendingAcquire)
-    } else if (partySubIdOrType && isGetRequest) {
-      url = await _getOracleEndpointByTypeAndSubId(partyIdType, partyIdentifier, partySubIdOrType, assertPendingAcquire)
-    } else {
-      url = await _getOracleEndpointByType(partyIdType, partyIdentifier, assertPendingAcquire)
-      if (partySubIdOrType) {
-        payload = { ...payload, partySubIdOrType }
-      }
+    step = 'determineOracleEndpoint'
+    const url = await determineOracleEndpoint({
+      method, params, query, payload, assertPendingAcquire
+    })
+    log.verbose(`Oracle endpoint: ${url}`)
+
+    if (method.toUpperCase() === RestMethods.GET) {
+      step = 'sendOracleGetRequest'
+      return await sendOracleGetRequest({
+        url, source, destination, headers, method, params, cache
+      })
     }
-    Logger.isDebugEnabled && Logger.debug(`Oracle endpoints: ${url}`)
-    const histTimerEnd = Metrics.getHistogram(
-      'egress_oracleRequest',
-      'Egress: oracleRequest',
-      ['success', 'hit']
-    ).startTimer()
-    try {
-      if (isGetRequest) {
-        let cachedOracleFspResponse
-        cachedOracleFspResponse = cache && cache.get(cache.createKey(`oracleSendRequest_${url}`))
-        if (!cachedOracleFspResponse) {
-          cachedOracleFspResponse = await request.sendRequest({
-            url,
-            headers,
-            source: headers[Enums.Http.Headers.FSPIOP.SOURCE],
-            destination: headers[Enums.Http.Headers.FSPIOP.DESTINATION] || Config.HUB_NAME,
-            method: method.toUpperCase(),
-            payload,
-            hubNameRegex
-          })
-          // Trying to cache the whole response object will fail because it contains circular references
-          // so we'll just cache the data property of the response.
-          cachedOracleFspResponse = {
-            data: cachedOracleFspResponse.data
-          }
-          cache && cache.set(
-            cache.createKey(`oracleSendRequest_${url}`),
-            cachedOracleFspResponse
-          )
-          histTimerEnd({ success: true, hit: false })
-        } else {
-          cachedOracleFspResponse = cachedOracleFspResponse.item
-          histTimerEnd({ success: true, hit: true })
-          Logger.isDebugEnabled && Logger.debug(`${new Date().toISOString()}, [oracleRequest]: cache hit for fsp for partyId lookup`)
-        }
 
-        return cachedOracleFspResponse
-      }
+    if (partySubIdOrType && payload) payload.partySubIdOrType = partySubIdOrType
 
-      if (isDeleteRequest && Config.DELETE_PARTICIPANT_VALIDATION_ENABLED) {
-        // If the request is a DELETE request, we need to ensure that the participant belongs to the requesting FSP
-        const getOracleResponse = await request.sendRequest({
-          url,
-          headers,
-          source: headers[Enums.Http.Headers.FSPIOP.SOURCE],
-          destination: headers[Enums.Http.Headers.FSPIOP.DESTINATION] || Config.HUB_NAME,
-          method: Enums.Http.RestMethods.GET,
-          payload,
-          hubNameRegex
-        })
+    if (method.toUpperCase() === RestMethods.DELETE && Config.DELETE_PARTICIPANT_VALIDATION_ENABLED) {
+      step = 'validatePartyDeletion'
+      await validatePartyDeletion({
+        url, source, destination, headers, method, params, payload
+      })
+    }
 
-        if (getOracleResponse.status === Enums.Http.ReturnCodes.OK.CODE) {
-          const participant = getOracleResponse.data
-          if (participant?.partyList?.length > 0) {
-            const party = participant.partyList[0]
-            if (party.fspId === headers[Enums.Http.Headers.FSPIOP.SOURCE]) {
-              return await request.sendRequest({
-                url,
-                headers,
-                source: headers[Enums.Http.Headers.FSPIOP.SOURCE],
-                destination: headers[Enums.Http.Headers.FSPIOP.DESTINATION] || Config.HUB_NAME,
-                method: method.toUpperCase(),
-                payload,
-                hubNameRegex
-              })
-            } else {
-              throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.DELETE_PARTY_INFO_ERROR, `The party ${partyIdType}:${partyIdentifier} does not belong to the requesting FSP`)
-            }
-          }
-        }
+    step = 'sendRequest'
+    return await request.sendRequest({
+      url,
+      headers,
+      source,
+      destination,
+      method,
+      payload,
+      hubNameRegex
+    })
+  } catch (err) {
+    log.error('error in oracleRequest: ', err)
+    throw countFspiopError(err, { operation, step, log })
+  }
+}
 
-        throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.PARTY_NOT_FOUND)
-      }
+const determineOracleEndpoint = async ({
+  method, params, query, payload, assertPendingAcquire
+}) => {
+  const partyIdType = params.Type
+  const partyIdentifier = params.ID
+  const partySubIdOrType = params?.SubId || query?.partySubIdOrType
+  const currency = payload?.currency || query?.currency
+  const isGetRequest = method.toUpperCase() === RestMethods.GET
+  let url
 
-      return await request.sendRequest({
+  if (currency && partySubIdOrType && isGetRequest) {
+    url = await _getOracleEndpointByTypeCurrencyAndSubId(partyIdType, partyIdentifier, currency, partySubIdOrType, assertPendingAcquire)
+  } else if (currency && isGetRequest) {
+    url = await _getOracleEndpointByTypeAndCurrency(partyIdType, partyIdentifier, currency, assertPendingAcquire)
+  } else if (partySubIdOrType && isGetRequest) {
+    url = await _getOracleEndpointByTypeAndSubId(partyIdType, partyIdentifier, partySubIdOrType, assertPendingAcquire)
+  } else {
+    url = await _getOracleEndpointByType(partyIdType, partyIdentifier, assertPendingAcquire)
+  }
+  return url
+}
+
+const sendOracleGetRequest = async ({
+  url, source, destination, headers, method, params, cache
+}) => {
+  const histTimerEnd = Metrics.getHistogram(
+    'egress_oracleRequest',
+    'Egress: oracleRequest',
+    ['success', 'hit']
+  ).startTimer()
+  const log = logger.child({ component: 'sendOracleGetRequest', params })
+
+  try {
+    let cachedOracleFspResponse
+    cachedOracleFspResponse = cache && cache.get(cache.createKey(`oracleSendRequest_${url}`))
+
+    if (!cachedOracleFspResponse) {
+      cachedOracleFspResponse = await request.sendRequest({
         url,
         headers,
-        source: headers[Enums.Http.Headers.FSPIOP.SOURCE],
-        destination: headers[Enums.Http.Headers.FSPIOP.DESTINATION] || Config.HUB_NAME,
-        method: method.toUpperCase(),
-        payload,
+        source,
+        destination,
+        method,
         hubNameRegex
       })
-    } catch (err) {
-      histTimerEnd({ success: false, hit: false })
-      throw err
+      // Trying to cache the whole response object will fail because it contains circular references
+      // so we'll just cache the data property of the response.
+      cachedOracleFspResponse = {
+        data: cachedOracleFspResponse.data
+      }
+      cache && cache.set(
+        cache.createKey(`oracleSendRequest_${url}`),
+        cachedOracleFspResponse
+      )
+      histTimerEnd({ success: true, hit: false })
+    } else {
+      cachedOracleFspResponse = cachedOracleFspResponse.item
+      histTimerEnd({ success: true, hit: true })
+      logger.debug('[oracleRequest]: cache hit for fsp for partyId lookup')
     }
+
+    return cachedOracleFspResponse
   } catch (err) {
-    const extensions = [{
-      key: 'system',
-      value: '["@hapi/catbox-memory","http"]'
-    }]
-    Logger.isErrorEnabled && Logger.error(`error in oracleRequest: ${err?.stack}`)
+    log.warn('error in sendOracleGetRequest: ', err)
+    histTimerEnd({ success: false, hit: false })
+
     // If the error was a 400 from the Oracle, we'll modify the error to generate a response to the
     // initiator of the request.
     if (
       err.name === 'FSPIOPError' &&
       err.apiErrorCode.code === ErrorHandler.Enums.FSPIOPErrorCodes.DESTINATION_COMMUNICATION_ERROR.code
     ) {
-      if (err.extensions.some(ext => (ext.key === 'status' && ext.value === Enums.Http.ReturnCodes.BADREQUEST.CODE))) {
+      const extensions = [{
+        key: 'system',
+        value: '["@hapi/catbox-memory","http"]'
+      }]
+      if (err.extensions.some(ext => (ext.key === 'status' && ext.value === ReturnCodes.BADREQUEST.CODE))) {
         throw ErrorHandler.Factory.createFSPIOPError(
           ErrorHandler.Enums.FSPIOPErrorCodes.PARTY_NOT_FOUND,
           undefined,
@@ -180,10 +185,11 @@ exports.oracleRequest = async (headers, method, params = {}, query = {}, payload
           undefined,
           extensions
         )
-        // Added error 404 to cover a special case of the Mowali implementation
-        // which uses mojaloop/als-oracle-pathfinder and currently returns 404
-        // and in which case the Mowali implementation expects back `DESTINATION_FSP_ERROR`.
-      } else if (err.extensions.some(ext => (ext.key === 'status' && ext.value === Enums.Http.ReturnCodes.NOTFOUND.CODE))) {
+      }
+      // Added error 404 to cover a special case of the Mowali implementation
+      // which uses mojaloop/als-oracle-pathfinder and currently returns 404
+      // and in which case the Mowali implementation expects back `DESTINATION_FSP_ERROR`.
+      if (err.extensions.some(ext => (ext.key === 'status' && ext.value === ReturnCodes.NOTFOUND.CODE))) {
         throw ErrorHandler.Factory.createFSPIOPError(
           ErrorHandler.Enums.FSPIOPErrorCodes.DESTINATION_FSP_ERROR,
           undefined,
@@ -193,13 +199,47 @@ exports.oracleRequest = async (headers, method, params = {}, query = {}, payload
         )
       }
     }
-    throw ErrorHandler.Factory.reformatFSPIOPError(
-      err,
-      undefined,
-      undefined,
-      extensions
-    )
+
+    throw err
+  }
+}
+
+const validatePartyDeletion = async ({
+  url, source, destination, headers, method, params, payload
+}) => {
+  const log = logger.child({ component: 'validatePartyDeletion', params })
+  // If the request is a DELETE request, we need to ensure that the participant belongs to the requesting FSP
+  const getParticipantResponse = await request.sendRequest({
+    url,
+    headers,
+    source,
+    destination,
+    method,
+    payload,
+    hubNameRegex
+  })
+
+  if (getParticipantResponse.status !== ReturnCodes.OK.CODE) {
+    const errMessage = `Invalid getOracleResponse status code: ${getParticipantResponse.status}`
+    log.warn(errMessage)
+    throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.PARTY_NOT_FOUND, errMessage)
+    // todo: clarify if we need to throw PARTY_NOT_FOUND
+  }
+
+  const participant = getParticipantResponse.data
+  if (!Array.isArray(participant?.partyList) || participant.partyList.length === 0) {
+    const errMessage = 'No participant found for the party'
+    log.warn(errMessage)
+    throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.DELETE_PARTY_INFO_ERROR, errMessage)
+  }
+
+  const party = participant.partyList[0] // todo: clarify why we check only the first party?
+  if (party.fspId !== source) {
+    const errMessage = `The party ${params.Type}:${params.ID} does not belong to the requesting FSP`
+    log.warn(errMessage)
+    throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.DELETE_PARTY_INFO_ERROR, errMessage)
   }
+  return true
 }
 
 /**
@@ -233,8 +273,10 @@ const _getOracleEndpointByTypeAndCurrency = async (partyIdType, partyIdentifier,
       )
     }
   } else {
-    Logger.isErrorEnabled && Logger.error(`Oracle type:${partyIdType} and currency:${currency} not found`)
-    throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ADD_PARTY_INFO_ERROR, `Oracle type:${partyIdType} and currency:${currency} not found`).toApiErrorObject(Config.ERROR_HANDLING)
+    const errMessage = `Oracle type:${partyIdType} and currency:${currency} not found`
+    logger.error(errMessage)
+    throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ADD_PARTY_INFO_ERROR, errMessage)
+      .toApiErrorObject(Config.ERROR_HANDLING)
   }
   return url
 }
@@ -269,8 +311,9 @@ const _getOracleEndpointByType = async (partyIdType, partyIdentifier, assertPend
       )
     }
   } else {
-    Logger.isErrorEnabled && Logger.error(`Oracle type:${partyIdType} not found`)
-    throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ADD_PARTY_INFO_ERROR, `Oracle type: ${partyIdType} not found`)
+    const errMessage = `Oracle type:${partyIdType} not found`
+    logger.error(errMessage)
+    throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ADD_PARTY_INFO_ERROR, errMessage)
   }
   return url
 }
@@ -306,8 +349,10 @@ const _getOracleEndpointByTypeAndSubId = async (partyIdType, partyIdentifier, pa
       )
     }
   } else {
-    Logger.isErrorEnabled && Logger.error(`Oracle type: ${partyIdType} and subId: ${partySubIdOrType} not found`)
-    throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ADD_PARTY_INFO_ERROR, `Oracle type: ${partyIdType} and subId: ${partySubIdOrType} not found`).toApiErrorObject(Config.ERROR_HANDLING)
+    const errMessage = `Oracle type: ${partyIdType} and subId: ${partySubIdOrType} not found`
+    logger.error(errMessage)
+    throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ADD_PARTY_INFO_ERROR, errMessage)
+      .toApiErrorObject(Config.ERROR_HANDLING)
   }
   return url
 }
@@ -344,16 +389,16 @@ const _getOracleEndpointByTypeCurrencyAndSubId = async (partyIdType, partyIdenti
       )
     }
   } else {
-    Logger.isErrorEnabled && Logger.error(`Oracle type: ${partyIdType}, currency: ${currency}, and subId: ${partySubIdOrType} not found`)
-    throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ADD_PARTY_INFO_ERROR, `Oracle type:${partyIdType}, currency:${currency} and subId: ${partySubIdOrType} not found`).toApiErrorObject(Config.ERROR_HANDLING)
+    const errMessage = `Oracle type: ${partyIdType}, currency: ${currency} and subId: ${partySubIdOrType} not found`
+    logger.error(errMessage)
+    throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ADD_PARTY_INFO_ERROR, errMessage)
+      .toApiErrorObject(Config.ERROR_HANDLING)
   }
   return url
 }
 
 /**
- * @function oracleBatchRequest
- *
- * @description This sends a request to the oracles that are registered to the ALS
+ * Sends a request to the oracles that are registered to the ALS
  *
  * @param {object} headers - incoming http request headers
  * @param {object} method - incoming http request method
@@ -361,9 +406,9 @@ const _getOracleEndpointByTypeCurrencyAndSubId = async (partyIdType, partyIdenti
  * @param {string} type - oracle type
  * @param {object} payload - the payload to send in the request
  *
- * @returns {object} returns the response from the oracle
+ * @returns {object} - response from the oracle
  */
-exports.oracleBatchRequest = async (headers, method, requestPayload, type, payload) => {
+const oracleBatchRequest = async (headers, method, requestPayload, type, payload) => {
   try {
     let oracleEndpointModel
     let url
@@ -383,22 +428,27 @@ exports.oracleBatchRequest = async (headers, method, requestPayload, type, paylo
       } else {
         url = oracleEndpointModel[0].value + Enums.EndPoints.FspEndpointTemplates.ORACLE_PARTICIPANTS_BATCH
       }
-      Logger.isDebugEnabled && Logger.debug(`Oracle endpoints: ${url}`)
+      logger.debug(`Oracle endpoints: ${url}`)
       return await request.sendRequest({
         url,
         headers,
-        source: headers[Enums.Http.Headers.FSPIOP.SOURCE],
-        destination: headers[Enums.Http.Headers.FSPIOP.DESTINATION] || Config.HUB_NAME,
+        source: headers[Headers.FSPIOP.SOURCE],
+        destination: headers[Headers.FSPIOP.DESTINATION] || Config.HUB_NAME,
         method,
         payload,
         hubNameRegex
       })
     } else {
-      Logger.isErrorEnabled && Logger.error(`Oracle type:${type} not found`)
+      logger.error(`Oracle type:${type} not found`)
       throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ADD_PARTY_INFO_ERROR, `Oracle type:${type} not found`)
     }
   } catch (err) {
-    Logger.isErrorEnabled && Logger.error(err)
+    logger.error('error in oracleBatchRequest: ', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
+
+module.exports = {
+  oracleRequest,
+  oracleBatchRequest
+}

package/src/server.js

@@ -45,7 +45,18 @@ const OracleEndpointCache = require('./models/oracle/oracleEndpointCached')
 const Handlers = require('./handlers/register')
 
 const connectDatabase = async (dbConfig) => {
-  return Db.connect(dbConfig)
+  await Db.connect(dbConfig)
+  logger.info('Database connected')
+}
+
+const initOpenApiBackend = async ({ isAdmin }) => {
+  const OpenAPISpecPath = Util.pathForInterface({ isAdmin, isMockInterface: false })
+  const apiHandlers = isAdmin
+    ? APIHandlers.AdminHandlers
+    : APIHandlers.ApiHandlers
+  const api = await OpenapiBackend.initialise(OpenAPISpecPath, apiHandlers)
+  logger.verbose('OpenAPI Backend initialized', { isAdmin })
+  return api
 }
 
 const migrate = async () => {
@@ -132,8 +143,7 @@ const initializeApi = async (appConfig) => {
     initializeInstrumentation(INSTRUMENTATION_METRICS_CONFIG)
   }
   await connectDatabase(DATABASE)
-  const OpenAPISpecPath = Util.pathForInterface({ isAdmin: false, isMockInterface: false })
-  const api = await OpenapiBackend.initialise(OpenAPISpecPath, APIHandlers.ApiHandlers)
+  const api = await initOpenApiBackend({ isAdmin: false })
 
   await Promise.all([
     Endpoints.initializeCache(CENTRAL_SHARED_ENDPOINT_CACHE_CONFIG, Util.hubNameConfig),
@@ -142,6 +152,7 @@ const initializeApi = async (appConfig) => {
     OracleEndpointCache.initialize(),
     Cache.initCache()
   ])
+  logger.verbose('all caches initialized')
 
   return createServer(API_PORT, api, Routes.APIRoutes(api), false, PROXY_CACHE_CONFIG)
 }
@@ -161,8 +172,8 @@ const initializeAdmin = async (appConfig) => {
   }
   await connectDatabase(DATABASE)
   RUN_MIGRATIONS && await migrate()
-  const OpenAPISpecPath = Util.pathForInterface({ isAdmin: true, isMockInterface: false })
-  const api = await OpenapiBackend.initialise(OpenAPISpecPath, APIHandlers.AdminHandlers)
+  const api = await initOpenApiBackend({ isAdmin: true })
+
   await Promise.all([
     OracleEndpointCache.initialize(),
     Cache.initCache()

package/test/fixtures/index.js

@@ -26,10 +26,11 @@
  ******/
 
 const { randomUUID } = require('node:crypto')
-const { Enum } = require('@mojaloop/central-services-shared')
+const { Enum, Util } = jest.requireActual('@mojaloop/central-services-shared')
 const isoFixtures = require('./iso')
 
 const { Headers } = Enum.Http
+const { encodePayload } = Util.StreamingProtocol
 
 const headersDto = ({
   source = 'fromDfsp',
@@ -37,14 +38,16 @@ const headersDto = ({
   proxy = '',
   date = new Date().toUTCString(),
   accept,
-  contentType
+  contentType,
+  addHeaders
 } = {}) => Object.freeze({
   [Headers.FSPIOP.SOURCE]: source,
   ...(destination && { [Headers.FSPIOP.DESTINATION]: destination }),
   ...(proxy && { [Headers.FSPIOP.PROXY]: proxy }),
   date,
   accept,
-  'content-type': contentType || accept
+  'content-type': contentType || accept,
+  ...(addHeaders && { ...addHeaders })
 })
 
 const partiesParamsDto = ({
@@ -72,12 +75,14 @@ const partiesCallHeadersDto = ({
   source,
   destination,
   proxy,
-  date
+  date,
+  addHeaders
 } = {}) => headersDto({
   source,
   destination,
   proxy,
   date,
+  addHeaders,
   accept: interopHeader('parties', '1'),
   contentType: interopHeader('parties', '1.1')
 })
@@ -141,6 +146,8 @@ const postParticipantsPayloadDto = ({
   ...(currency && { currency })
 })
 
+const dataUriDto = (payload = {}) => encodePayload(JSON.stringify(payload), 'application/json')
+
 const errorCallbackResponseDto = ({
   errorCode = '1234',
   errorDescription = 'Error description',
@@ -191,6 +198,7 @@ module.exports = {
   oracleRequestResponseDto,
   putPartiesSuccessResponseDto,
   postParticipantsPayloadDto,
+  dataUriDto,
   errorCallbackResponseDto,
   expiredCacheKeyDto,
   mockAlsRequestDto,

package/test/integration/api/parties.test.js

@@ -62,6 +62,7 @@ describe('Parties Endpoints Tests -->', () => {
         partyIdType: PARTY_ID_TYPE,
         source: PAYER_DFSP,
         destination: ''
+        // addHeaders: { 'x-response-status': '503' }
       })
       expect(result.status).toBe(202)
 

package/test/unit/domain/parties/parties.test.js

@@ -587,20 +587,20 @@ describe('Parties Tests', () => {
     it('successfully sends the callback to the participant', async () => {
       expect.hasAssertions()
       // Arrange
-      participant.validateParticipant = sandbox.stub().resolves({
-        name: 'fsp1'
-      })
+      participant.validateParticipant = sandbox.stub().resolves({})
       participant.sendRequest = sandbox.stub().resolves()
       const payload = JSON.stringify({ testPayload: true })
       const dataUri = encodePayload(payload, 'application/json')
+      const destination = 'destFsp'
+      const headers = fixtures.partiesCallHeadersDto({ destination })
 
       // Act
-      await partiesDomain.putPartiesByTypeAndID(Helper.putByTypeIdRequest.headers, Helper.putByTypeIdRequest.params, 'put', payload, dataUri, null, proxyCache)
+      await partiesDomain.putPartiesByTypeAndID(headers, Helper.putByTypeIdRequest.params, 'put', payload, dataUri, null, proxyCache)
 
       // Assert
       expect(participant.sendRequest.callCount).toBe(1)
       const sendRequestCallArgs = participant.sendRequest.getCall(0).args
-      expect(sendRequestCallArgs[1]).toStrictEqual('fsp1')
+      expect(sendRequestCallArgs[1]).toBe(destination)
       participant.sendRequest.reset()
     })
 
@@ -927,14 +927,15 @@ describe('Parties Tests', () => {
       expect(sendErrorCallArgs[1]).toBe(expectedCallbackEnpointType)
     })
 
-    it('should handle notValidPayeeIdentifier case, and delete partyId from oracle', async () => {
+    it('should handle external party error callback, and delete partyId from oracle', async () => {
       Config.PROXY_CACHE_CONFIG.enabled = true
       const errorCode = MojaloopApiErrorCodes.PAYEE_IDENTIFIER_NOT_VALID.code
       const payload = fixtures.errorCallbackResponseDto({ errorCode })
-      const source = `source-${Date.now()}`
+      const destination = `dest-${Date.now()}`
       const proxy = `proxy-${Date.now()}`
-      const headers = fixtures.partiesCallHeadersDto({ source, proxy })
+      const headers = fixtures.partiesCallHeadersDto({ destination, proxy })
       const { params } = Helper.putByTypeIdRequest
+      participant.validateParticipant = sandbox.stub().resolves({})
       participant.sendRequest = sandbox.stub().resolves()
       participant.sendErrorToParticipant = sandbox.stub().resolves()
       oracleEndpointCached.getOracleEndpointByType = sandbox.stub().resolves([
@@ -944,13 +945,14 @@ describe('Parties Tests', () => {
 
       await partiesDomain.putPartiesErrorByTypeAndID(headers, params, payload, '', null, null, proxyCache)
 
-      expect(participant.sendRequest.callCount).toBe(0)
       expect(oracle.oracleRequest.callCount).toBe(1)
-      const [, method] = oracle.oracleRequest.getCall(0).args
-      expect(method).toBe(RestMethods.DELETE)
-      // todo: think, how to stub getPartiesByTypeAndID call
-      // expect(partiesDomain.getPartiesByTypeAndID.callCount).toBe(1)
-      // expect(participant.sendErrorToParticipant.callCount).toBe(0)
+      expect(oracle.oracleRequest.lastCall.args[1]).toBe(RestMethods.DELETE)
+      expect(participant.sendRequest.callCount).toBe(0)
+      expect(participant.sendErrorToParticipant.callCount).toBe(1)
+      // eslint-disable-next-line no-unused-vars
+      const [sentTo, _, data] = participant.sendErrorToParticipant.lastCall.args
+      expect(sentTo).toBe(destination)
+      expect(data.errorInformation.errorCode).toBe('2003')
     })
   })
 })

package/test/unit/domain/parties/services/BasePartiesService.test.js

@@ -54,7 +54,8 @@ describe('BasePartiesService Tests -->', () => {
     expect(sentTo).toBe(source)
     expect(payload.Rpt.Rsn.Cd).toBe('2001')
     expect(payload.Rpt.OrgnlId).toBe(`${params.Type}/${params.ID}`)
-    expect(payload.Assgnmt.Assgnr.Agt.FinInstnId.Othr.Id).toBe(source)
+    expect(payload.Assgnmt.Assgne.Agt.FinInstnId.Othr.Id).toBe(source)
+    expect(payload.Assgnmt.Assgnr.Agt.FinInstnId.Othr.Id).toBe(config.HUB_NAME)
   })
 
   test('should remove proxy getParties timeout cache key', async () => {

package/test/unit/domain/parties/services/GetPartiesService.test.js

@@ -25,6 +25,7 @@
  --------------
  ******/
 
+const { setTimeout: sleep } = require('node:timers/promises')
 const {
   createMockDeps,
   createProxyCacheMock,
@@ -197,6 +198,51 @@ describe('GetPartiesService Tests -->', () => {
       expect(deps.proxyCache.receivedErrorResponse).toHaveBeenCalledTimes(1)
       expect(participantMock.sendRequest.mock.lastCall[1]).toBe(proxyOk)
     })
+
+    const throwDelayedErrorOnNthCall = (N, delay = 1000, error = new Error('Nth call Delayed Error')) => {
+      let count = 0
+      return async () => {
+        count++
+        if (count !== N) return {}
+        await sleep(1000)
+        throw error
+      }
+    }
+
+    const prepareGetPartiesServiceForDelayedProxyError = () => {
+      participantMock.sendRequest = jest.fn(throwDelayedErrorOnNthCall(2)) // throw error on 2nd proxy call
+      const proxies = createProxiesUtilMock({
+        getAllProxiesNames: jest.fn().mockResolvedValue(['proxy1', 'proxy2'])
+      })
+      const proxyCache = createProxyCacheMock({
+        receivedErrorResponse: jest.fn().mockResolvedValue(true) // failed proxy request is last in inter-scheme discovery flow
+      })
+      const deps = createMockDeps({ proxies, proxyCache })
+      const headers = fixtures.partiesCallHeadersDto({ destination: '' })
+      const params = fixtures.partiesParamsDto()
+
+      return new GetPartiesService(deps, { headers, params })
+    }
+
+    test('should throw an error if proxyRequest failed after delay, and other proxies have already replied', async () => {
+      expect.assertions(1)
+      const service = prepareGetPartiesServiceForDelayedProxyError()
+      const { headers } = service.inputs
+
+      await expect(service.triggerInterSchemeDiscoveryFlow(headers))
+        .rejects.toThrow(ERROR_MESSAGES.noSuccessfulProxyDiscoveryResponses)
+    })
+
+    test('should send error callback in ISO format if proxyRequest failed after delay, and other proxies have already replied', async () => {
+      const service = prepareGetPartiesServiceForDelayedProxyError()
+      const { headers } = service.inputs
+      service.deps.config.API_TYPE = API_TYPES.iso20022
+
+      await service.triggerInterSchemeDiscoveryFlow(headers)
+        .catch(err => service.handleError(err))
+      expect(participantMock.sendErrorToParticipant).toHaveBeenCalledTimes(1)
+      expect(participantMock.sendErrorToParticipant.mock.lastCall[2].Rpt.Rsn.Cd).toBe('3200')
+    })
   })
 
   describe('setProxyGetPartiesTimeout Tests', () => {

package/test/unit/domain/parties/services/PutPartiesErrorService.test.js

@@ -25,7 +25,7 @@
  --------------
  ******/
 
-const { createMockDeps, oracleMock } = require('./deps')
+const { createMockDeps, oracleMock, participantMock } = require('./deps')
 // ↑ should be first require to mock external deps ↑
 const { PutPartiesErrorService } = require('#src/domain/parties/services/index')
 const fixtures = require('#test/fixtures/index')
@@ -37,14 +37,41 @@ describe('PutPartiesErrorService Tests -->', () => {
     jest.clearAllMocks()
   })
 
-  test('should cleanup oracle and trigger discovery flow for party from external dfsp', async () => {
-    const headers = fixtures.partiesCallHeadersDto({ proxy: 'proxyA' })
+  test('should cleanup oracle and forward SERVICE_CURRENTLY_UNAVAILABLE error for party from external dfsp', async () => {
+    participantMock.validateParticipant = jest.fn().mockResolvedValue({})
+    const destination = 'destFsp'
+    const headers = fixtures.partiesCallHeadersDto({ destination, proxy: 'proxyA' })
     const params = fixtures.partiesParamsDto()
-    const service = new PutPartiesErrorService(createMockDeps(), { headers, params })
+    const dataUri = fixtures.dataUriDto()
+    const service = new PutPartiesErrorService(createMockDeps(), { headers, params, dataUri })
 
-    const needDiscovery = await service.handleRequest()
-    expect(needDiscovery).toBe(true)
-    expect(oracleMock.oracleRequest.mock.calls.length).toBe(1)
+    await service.handleRequest()
+    expect(oracleMock.oracleRequest).toHaveBeenCalledTimes(1)
     expect(oracleMock.oracleRequest.mock.lastCall[1]).toBe(RestMethods.DELETE)
+    expect(participantMock.sendErrorToParticipant).toHaveBeenCalledTimes(1)
+    // eslint-disable-next-line no-unused-vars
+    const [sentTo, _, payload] = participantMock.sendErrorToParticipant.mock.lastCall
+    expect(sentTo).toBe(destination)
+    expect(payload.errorInformation.errorCode).toBe('2003')
+  })
+
+  test('should NOT cleanup oracle if destination is external', async () => {
+    const destination = 'externalDfsp'
+    const proxyDest = 'proxyDest'
+    const deps = createMockDeps()
+    deps.participant.validateParticipant = jest.fn().mockResolvedValue(null)
+    deps.proxyCache.lookupProxyByDfspId = jest.fn().mockResolvedValue(proxyDest)
+
+    const headers = fixtures.partiesCallHeadersDto({
+      destination, proxy: 'proxyA'
+    })
+    const params = fixtures.partiesParamsDto()
+    const dataUri = fixtures.dataUriDto()
+    const service = new PutPartiesErrorService(deps, { headers, params, dataUri })
+
+    await service.handleRequest()
+    expect(oracleMock.oracleRequest).not.toHaveBeenCalled()
+    expect(participantMock.sendErrorToParticipant).toHaveBeenCalledTimes(1)
+    expect(participantMock.sendErrorToParticipant.mock.lastCall[0]).toBe(proxyDest)
   })
 })

package/test/util/apiClients/AlsApiClient.js

@@ -8,9 +8,9 @@ class AlsProxyApiClient extends BasicApiClient {
     super({ ...deps, baseURL })
   }
 
-  async getPartyByIdAndType ({ partyId, partyIdType, source, destination, proxy = '' }) {
+  async getPartyByIdAndType ({ partyId, partyIdType, source, destination, proxy = '', addHeaders = null }) {
     return this.sendPartyRequest({
-      partyId, partyIdType, source, destination, proxy
+      partyId, partyIdType, source, destination, proxy, addHeaders
     })
   }
 
@@ -27,10 +27,12 @@ class AlsProxyApiClient extends BasicApiClient {
     })
   }
 
-  async sendPartyRequest ({ partyId, partyIdType, source, destination, proxy = '', body = null, isError = false }) {
+  async sendPartyRequest ({
+    partyId, partyIdType, source, destination, proxy = '', body = null, isError = false, addHeaders = null
+  }) {
     const method = body ? 'PUT' : 'GET'
     const url = `/parties/${partyIdType}/${partyId}${isError ? '/error' : ''}`
-    const headers = this.fixtures.partiesCallHeadersDto({ source, destination, proxy })
+    const headers = this.fixtures.partiesCallHeadersDto({ source, destination, proxy, addHeaders })
 
     return this.sendRequest({
       method,