account-lookup-service 17.7.0-snapshot.0 → 17.7.0-snapshot.2

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "account-lookup-service",
   "description": "Account Lookup Service is used to validate Party and Participant lookups.",
-  "version": "17.7.0-snapshot.0",
+  "version": "17.7.0-snapshot.2",
   "license": "Apache-2.0",
   "author": "ModusBox",
   "contributors": [
+    "Eugen Klymniuk <eugen.klymniuk@infitx.com>",
     "Rajiv Mothilal <rajiv.mothilal@modusbox.com>",
     "Matt Kingston <matt.kingston@modusbox.com>",
     "Lewis Daly <lewisd@crosslaketech.com>",
@@ -93,13 +94,13 @@
     "@mojaloop/central-services-health": "15.0.4",
     "@mojaloop/central-services-logger": "11.7.0",
     "@mojaloop/central-services-metrics": "12.5.0",
-    "@mojaloop/central-services-shared": "18.23.1-snapshot.0",
-    "@mojaloop/central-services-stream": "11.5.1",
+    "@mojaloop/central-services-shared": "18.23.1",
+    "@mojaloop/central-services-stream": "11.5.2",
     "@mojaloop/database-lib": "11.1.4",
-    "@mojaloop/event-sdk": "14.3.2",
-    "@mojaloop/inter-scheme-proxy-cache-lib": "2.4.0-snapshot.0",
-    "@mojaloop/ml-schema-transformer-lib": "2.5.8",
-    "@mojaloop/sdk-standard-components": "19.11.0",
+    "@mojaloop/event-sdk": "14.4.0",
+    "@mojaloop/inter-scheme-proxy-cache-lib": "2.4.0",
+    "@mojaloop/ml-schema-transformer-lib": "2.6.0",
+    "@mojaloop/sdk-standard-components": "19.11.1",
     "@now-ims/hapi-now-auth": "2.1.0",
     "ajv": "8.17.1",
     "ajv-keywords": "5.1.0",
@@ -171,12 +172,12 @@
     "jest-junit": "16.0.0",
     "jsdoc": "4.0.4",
     "nodemon": "3.1.9",
-    "npm-check-updates": "17.1.15",
+    "npm-check-updates": "17.1.16",
     "nyc": "17.1.0",
     "pre-commit": "1.2.2",
     "proxyquire": "2.1.3",
     "replace": "^1.2.2",
-    "sinon": "19.0.4",
+    "sinon": "20.0.0",
     "standard": "17.1.2",
     "standard-version": "^9.5.0",
     "swagmock": "1.0.0"

package/src/constants.js

@@ -25,6 +25,8 @@
  --------------
  ******/
 
+const { API_TYPES } = require('@mojaloop/central-services-shared').Util.Hapi
+
 const ERROR_MESSAGES = Object.freeze({
   emptyFilteredPartyList: 'Empty oracle partyList, filtered based on callbackEndpointType',
   failedToCacheSendToProxiesList: 'Failed to cache sendToProxiesList',
@@ -40,6 +42,7 @@ const HANDLER_TYPES = Object.freeze({
 })
 
 module.exports = {
+  API_TYPES,
   ERROR_MESSAGES,
   HANDLER_TYPES
 }

package/src/domain/parties/deps.js

@@ -32,6 +32,7 @@ const oracle = require('../../models/oracle/facade')
 const participant = require('../../models/participantEndpoint/facade')
 const partiesUtils = require('./partiesUtils')
 
+/** @returns {PartiesDeps} */
 const createDeps = ({ cache, proxyCache, childSpan, log = logger }) => Object.freeze({
   cache,
   proxyCache,

package/src/domain/parties/partiesUtils.js

@@ -25,13 +25,9 @@
  --------------
  ******/
 
-const { Enum, Util: { Hapi } } = require('@mojaloop/central-services-shared')
-const { MojaloopApiErrorCodes } = require('@mojaloop/sdk-standard-components').Errors
-// todo: check why do we need sdk-standard-components deps here !!!
-const ErrorHandler = require('@mojaloop/central-services-error-handling')
-
-const participant = require('../../models/participantEndpoint/facade')
+const { Enum } = require('@mojaloop/central-services-shared')
 const { TransformFacades } = require('../../lib')
+const { API_TYPES } = require('../../constants')
 
 const { FspEndpointTypes } = Enum.EndPoints
 const { Headers } = Enum.Http
@@ -50,7 +46,7 @@ const errorPartyCbType = (partySubId) => partySubId
 
 const makePutPartiesErrorPayload = async (config, fspiopError, headers, params) => {
   const body = fspiopError.toApiErrorObject(config.ERROR_HANDLING)
-  return config.API_TYPE === Hapi.API_TYPES.iso20022
+  return config.API_TYPE === API_TYPES.iso20022
     ? (await TransformFacades.FSPIOP.parties.putError({ body, headers, params })).body
     : body
 }
@@ -81,38 +77,12 @@ const swapSourceDestinationHeaders = (headers) => {
   }
 }
 
-// todo: check if we need this function
-const createErrorHandlerOnSendingCallback = (config, logger) => async (err, headers, params, requester) => {
-  try {
-    logger.error('error in sending parties callback: ', err)
-    const sendTo = requester || headers[Headers.FSPIOP.SOURCE]
-    const errorCallbackEndpointType = errorPartyCbType(params.SubId)
-    const fspiopError = ErrorHandler.Factory.reformatFSPIOPError(err)
-    const errInfo = await makePutPartiesErrorPayload(config, fspiopError, headers, params)
-
-    await participant.sendErrorToParticipant(sendTo, errorCallbackEndpointType, errInfo, headers, params)
-
-    logger.info('handleErrorOnSendingCallback in done', { sendTo, params, errInfo })
-    return fspiopError
-  } catch (exc) {
-    // We can't do anything else here- we _must_ handle all errors _within_ this function because
-    // we've already sent a sync response- we cannot throw.
-    logger.error('failed to handleErrorOnSendingCallback. No further processing! ', exc)
-  }
-}
-
-function isNotValidPayeeCase (payload) {
-  return payload?.errorInformation?.errorCode === MojaloopApiErrorCodes.PAYEE_IDENTIFIER_NOT_VALID.code
-}
-
 module.exports = {
   getPartyCbType,
   putPartyCbType,
   errorPartyCbType,
   makePutPartiesErrorPayload,
-  createErrorHandlerOnSendingCallback,
   alsRequestDto,
   partiesRequestOptionsDto,
-  swapSourceDestinationHeaders,
-  isNotValidPayeeCase
+  swapSourceDestinationHeaders
 }

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

@@ -35,6 +35,21 @@ const { FspEndpointTypes, FspEndpointTemplates } = Enum.EndPoints
 const { Headers, RestMethods } = Enum.Http
 
 /**
+ * @typedef {Object} PartiesDeps
+ * @property {Object} cache
+ * @property {Object} proxyCache
+ * @property {Object} log
+ * @property {Object} config
+ * @property {Object} oracle
+ * @property {Object} participant
+ * @property {Proxies} proxies
+ * @property {Object} partiesUtils
+ * @property {Object} [childSpan]
+ */
+
+/**
+ * Input parameters from party lookup request
+ *
  * @typedef {Object} PartiesInputs
  * @property {Object} headers - incoming http request headers.
  * @property {Object} params - uri parameters of the http request.
@@ -43,13 +58,25 @@ const { Headers, RestMethods } = Enum.Http
  * @property {string} [dataUri] - encoded payload of the request being sent out.
  */
 
+/**
+ * Any calculated values we get during request processing
+ *
+ * @typedef {Object} PartiesModelState
+ * @property {string} destination - The destination DFSP ID from headers
+ * @property {string} source - The source DFSP ID from headers
+ * @property {string} [proxy] - The proxy DFSP ID from headers, if present
+ * @property {string} requester - The entity initiating the request (either a DFSP in scheme or a proxy)
+ * @property {boolean} proxyEnabled - Indicates whether proxy functionality is enabled in the current configuration
+ * @property {StepState} stepState - Processing steps state
+ */
+
 class BasePartiesService {
-  #deps
+  #deps // see PartiesDeps
   #inputs // see PartiesInputs
-  #state // any calculated values we get during request processing
+  #state // see PartiesModelState
 
   /**
-   * @param {Object} deps - The dependencies required by the class instance.
+   * @param {PartiesDeps} deps - The dependencies required by the class instance.
    * @param {PartiesInputs} inputs - The input parameters from incoming http request.
    * @return {void}
    */
@@ -63,8 +90,13 @@ class BasePartiesService {
     })
   }
 
+  /** @returns {PartiesDeps} */
   get deps () { return this.#deps }
+
+  /** @returns {PartiesInputs} */
   get inputs () { return this.#inputs }
+
+  /** @returns {PartiesModelState} */
   get state () { return this.#state }
 
   async handleError (error) {
@@ -110,6 +142,12 @@ class BasePartiesService {
     return this.deps.oracle.oracleRequest(headers, RestMethods.DELETE, params, null, null, this.deps.cache)
   }
 
+  async removeProxyGetPartiesTimeout (alsReq) {
+    const isRemoved = await this.deps.proxyCache.removeProxyGetPartiesTimeout(alsReq)
+    this.log.debug('removeProxyGetPartiesTimeout is done', { isRemoved, alsReq })
+    return isRemoved
+  }
+
   createFspiopIdNotFoundError (errMessage, log = this.log) {
     log.warn(errMessage)
     return ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
@@ -124,12 +162,14 @@ class BasePartiesService {
     return this.state.stepState?.step
   }
 
+  /** @returns {PartiesModelState} */
   #initiateState () {
     const { headers } = this.inputs
     return {
       destination: headers[Headers.FSPIOP.DESTINATION],
       source: headers[Headers.FSPIOP.SOURCE],
       proxy: headers[Headers.FSPIOP.PROXY],
+      requester: '', // dfsp in scheme  OR  proxy
       proxyEnabled: !!(this.deps.config.PROXY_CACHE_CONFIG?.enabled && this.deps.proxyCache),
       stepState: initStepState()
     }

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

@@ -39,7 +39,6 @@ class GetPartiesService extends BasePartiesService {
     // without consulting any oracles.
     this.log.info('handling getParties request...', { source, destination, proxy })
     this.state.requester = await this.validateRequester()
-    // dfsp in scheme  OR  proxy
 
     if (destination) {
       await this.forwardRequestToDestination()
@@ -48,12 +47,11 @@ class GetPartiesService extends BasePartiesService {
 
     const response = await this.sendOracleDiscoveryRequest()
     if (Array.isArray(response?.data?.partyList) && response.data.partyList.length > 0) {
-      const partyList = this.filterOraclePartyList(response)
-      await this.processOraclePartyList(partyList)
-      return
+      const isDone = await this.processOraclePartyListResponse(response)
+      if (isDone) return
     }
 
-    this.log.info('empty partyList form oracle, checking inter-scheme discovery flow...')
+    this.log.info('no forwarded requests for oracle partyList')
     const fspiopError = await this.triggerInterSchemeDiscoveryFlow(this.inputs.headers)
     if (fspiopError) {
       this.state.fspiopError = fspiopError // todo: think, if we need this
@@ -85,7 +83,7 @@ class GetPartiesService extends BasePartiesService {
       throw super.createFspiopIdNotFoundError('failed to addDfspIdToProxyMapping', log)
     }
 
-    log.info('source is added to proxyMapping cache:', { proxy, isCached })
+    log.info('source is added to proxyMapping cache')
     return proxy
   }
 
@@ -113,89 +111,26 @@ class GetPartiesService extends BasePartiesService {
     log.info('discovery getPartiesByTypeAndID request was sent', { sendTo })
   }
 
-  filterOraclePartyList (response) {
-    // Oracle's API is a standard rest-style end-point Thus a GET /party on the oracle will return all participant-party records.
-    // We must filter the results based on the callbackEndpointType to make sure we remove records containing partySubIdOrType when we are in FSPIOP_CALLBACK_URL_PARTIES_GET mode:
-    this.stepInProgress('filterOraclePartyList-5')
-    const { params } = this.inputs
-    const callbackEndpointType = this.deps.partiesUtils.getPartyCbType(params.SubId)
-    let filteredPartyList
-
-    switch (callbackEndpointType) {
-      case FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTIES_GET:
-        filteredPartyList = response.data.partyList.filter(party => party.partySubIdOrType == null) // Filter records that DON'T contain a partySubIdOrType
-        break
-      case FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTIES_SUB_ID_GET:
-        filteredPartyList = response.data.partyList.filter(party => party.partySubIdOrType === params.SubId) // Filter records that match partySubIdOrType
-        break
-      default:
-        filteredPartyList = response // Fallback to providing the standard list
-    }
-
-    if (!Array.isArray(filteredPartyList) || !filteredPartyList.length) {
-      throw super.createFspiopIdNotFoundError(ERROR_MESSAGES.emptyFilteredPartyList)
-    }
-
-    return filteredPartyList
+  async sendOracleDiscoveryRequest () {
+    this.stepInProgress('#sendOracleDiscoveryRequest')
+    const { headers, params, query } = this.inputs
+    return this.deps.oracle.oracleRequest(headers, RestMethods.GET, params, query, undefined, this.deps.cache)
   }
 
-  async processOraclePartyList (partyList) {
+  async processOraclePartyListResponse (response) {
     this.stepInProgress('processOraclePartyList')
-    const { headers, params } = this.inputs
-
-    let sentCount = 0 // if sentCount === 0 after sending, we send idNotFound error
-    const sending = partyList.map(async party => {
-      const { fspId } = party
-
-      const schemeParticipant = await this.validateParticipant(fspId)
-      if (schemeParticipant) {
-        sentCount++
-        this.log.info('participant is in scheme, so forwarding to it...', { fspId })
-        return this.#forwardGetPartiesRequest({
-          sendTo: fspId,
-          headers: GetPartiesService.overrideDestinationHeader(headers, fspId),
-          params
-        })
-      }
-
-      if (this.state.proxyEnabled) {
-        const proxyName = await this.deps.proxyCache.lookupProxyByDfspId(fspId)
-        if (!proxyName) {
-          this.log.warn('no proxyMapping for external DFSP!  Deleting reference in oracle...', { fspId })
-          return super.sendDeleteOracleRequest(headers, params)
-          // todo: check if it won't delete all parties
-        }
-
-        // Coz there's no destination header, it means we're inside initial inter-scheme discovery phase.
-        // So we should proceed only if source is in scheme (local participant)
-        const schemeSource = await this.validateParticipant(this.state.source)
-        if (schemeSource) {
-          sentCount++
-          this.log.info('participant is NOT in scheme, but source is. So forwarding to proxy...', { fspId, proxyName })
-          return this.#forwardGetPartiesRequest({
-            sendTo: proxyName,
-            headers: GetPartiesService.overrideDestinationHeader(headers, fspId),
-            params
-          })
-        }
-      }
-    })
-    await Promise.all(sending)
-    this.log.verbose('processOraclePartyList is done', { sentCount })
-
-    if (sentCount === 0) throw super.createFspiopIdNotFoundError(ERROR_MESSAGES.noDiscoveryRequestsForwarded)
-  }
-
-  async getFilteredProxyList (proxy) {
-    this.stepInProgress('getFilteredProxyList')
-    if (!this.state.proxyEnabled) {
-      this.log.warn('proxyCache is not enabled')
-      return []
-    }
-
-    const proxyNames = await this.deps.proxies.getAllProxiesNames(this.deps.config.SWITCH_ENDPOINT)
-    this.log.debug('getAllProxiesNames is done', { proxyNames })
-    return proxyNames.filter(name => name !== proxy)
+    const partyList = this.#filterOraclePartyList(response)
+
+    let sentCount = 0
+    await Promise.all(partyList.map(async party => {
+      const isSent = await this.#processSingleOracleParty(party)
+      if (isSent) sentCount++
+    }))
+
+    const isDone = sentCount > 0
+    this.log.verbose('processOraclePartyList is done', { isDone, sentCount })
+    // if NOT isDone, need to trigger interScheme discovery flow
+    return isDone
   }
 
   async triggerInterSchemeDiscoveryFlow (headers) {
@@ -204,9 +139,9 @@ class GetPartiesService extends BasePartiesService {
     const log = this.log.child({ method: 'triggerInterSchemeDiscoveryFlow' })
     log.verbose('triggerInterSchemeDiscoveryFlow start...', { proxy, source })
 
-    const proxyNames = await this.getFilteredProxyList(proxy)
+    const proxyNames = await this.#getFilteredProxyList(proxy)
     if (!proxyNames.length) {
-      return this.sendPartyNotFoundErrorCallback(headers)
+      return this.#sendPartyNotFoundErrorCallback(headers)
     }
 
     this.stepInProgress('setSendToProxiesList-10')
@@ -218,7 +153,7 @@ class GetPartiesService extends BasePartiesService {
       throw super.createFspiopIdNotFoundError(ERROR_MESSAGES.failedToCacheSendToProxiesList, log)
     }
 
-    this.stepInProgress('sendingProxyRequests-11')
+    this.stepInProgress('sendingProxyRequests')
     const sending = proxyNames.map(
       sendTo => this.#forwardGetPartiesRequest({ sendTo, headers, params })
         .then(({ status, data } = {}) => ({ status, data }))
@@ -235,7 +170,80 @@ class GetPartiesService extends BasePartiesService {
     }
   }
 
-  async sendPartyNotFoundErrorCallback (headers) {
+  isLocalSource () {
+    const isLocal = this.state.source === this.state.requester
+    this.log.debug(`isLocalSource: ${isLocal}`)
+    return isLocal
+  }
+
+  #filterOraclePartyList (response) {
+    // Oracle's API is a standard rest-style end-point Thus a GET /party on the oracle will return all participant-party records.
+    // We must filter the results based on the callbackEndpointType to make sure we remove records containing partySubIdOrType when we are in FSPIOP_CALLBACK_URL_PARTIES_GET mode:
+    this.stepInProgress('filterOraclePartyList')
+    const { params } = this.inputs
+    const callbackEndpointType = this.deps.partiesUtils.getPartyCbType(params.SubId)
+    let filteredPartyList
+
+    switch (callbackEndpointType) {
+      case FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTIES_GET:
+        filteredPartyList = response.data.partyList.filter(party => party.partySubIdOrType == null) // Filter records that DON'T contain a partySubIdOrType
+        break
+      case FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTIES_SUB_ID_GET:
+        filteredPartyList = response.data.partyList.filter(party => party.partySubIdOrType === params.SubId) // Filter records that match partySubIdOrType
+        break
+      default:
+        filteredPartyList = response // Fallback to providing the standard list
+    }
+
+    if (!Array.isArray(filteredPartyList) || !filteredPartyList.length) {
+      throw super.createFspiopIdNotFoundError(ERROR_MESSAGES.emptyFilteredPartyList)
+    }
+
+    return filteredPartyList
+  }
+
+  /** @returns {Promise<boolean>} - is request forwarded to participant */
+  async #processSingleOracleParty (party) {
+    const { headers, params } = this.inputs
+    const { fspId } = party
+
+    const schemeParticipant = await this.validateParticipant(fspId)
+    if (schemeParticipant) {
+      this.log.info('participant is in scheme, so forwarding to it...', { fspId })
+      await this.#forwardGetPartiesRequest({
+        sendTo: fspId,
+        headers: GetPartiesService.overrideDestinationHeader(headers, fspId),
+        params
+      })
+      return true
+    }
+
+    if (this.state.proxyEnabled) {
+      const proxyName = await this.deps.proxyCache.lookupProxyByDfspId(fspId)
+      if (!proxyName) {
+        this.log.warn('no proxyMapping for external DFSP!  Deleting reference in oracle...', { fspId })
+        await super.sendDeleteOracleRequest(headers, params)
+        // todo: check if it won't delete all parties
+        return false
+      }
+
+      // Coz there's no destination header, it means we're inside initial inter-scheme discovery phase.
+      // So we should proceed only if source is in scheme (local participant)
+      const isLocalSource = this.isLocalSource()
+      if (isLocalSource) {
+        this.log.info('participant is NOT in scheme, but source is. So forwarding to proxy...', { fspId, proxyName })
+        await this.#forwardGetPartiesRequest({ // todo: add timeout if sendTo is proxy
+          sendTo: proxyName,
+          headers: GetPartiesService.overrideDestinationHeader(headers, fspId),
+          params
+        })
+        return true
+      }
+    }
+    return false
+  }
+
+  async #sendPartyNotFoundErrorCallback (headers) {
     const { params } = this.inputs
     const fspiopError = super.createFspiopIdNotFoundError('No proxy found to start inter-scheme discovery flow')
 
@@ -247,19 +255,53 @@ class GetPartiesService extends BasePartiesService {
     return fspiopError
   }
 
-  async sendOracleDiscoveryRequest () {
-    this.stepInProgress('sendOracleDiscoveryRequest')
-    const { headers, params, query } = this.inputs
-    return this.deps.oracle.oracleRequest(headers, RestMethods.GET, params, query, undefined, this.deps.cache)
-  }
-
   async #forwardGetPartiesRequest ({ sendTo, headers, params }) {
     this.stepInProgress('#forwardGetPartiesRequest')
     const callbackEndpointType = this.deps.partiesUtils.getPartyCbType(params.SubId)
     const options = this.deps.partiesUtils.partiesRequestOptionsDto(params)
 
-    return this.deps.participant.sendRequest(headers, sendTo, callbackEndpointType, RestMethods.GET, undefined, options, this.deps.childSpan)
+    const sentResult = await this.deps.participant.sendRequest(
+      headers, sendTo, callbackEndpointType, RestMethods.GET, undefined, options, this.deps.childSpan
+    )
+    await this.#setProxyGetPartiesTimeout(sendTo)
+    return sentResult
+  }
+
+  async #getFilteredProxyList (proxy) {
+    this.stepInProgress('#getFilteredProxyList')
+    if (!this.state.proxyEnabled) {
+      this.log.warn('proxyCache is not enabled')
+      return []
+    }
+
+    const proxyNames = await this.deps.proxies.getAllProxiesNames(this.deps.config.SWITCH_ENDPOINT)
+    this.log.debug('getAllProxiesNames is done', { proxyNames })
+    return proxyNames.filter(name => name !== proxy)
+  }
+
+  async #setProxyGetPartiesTimeout (sendTo) {
+    const isLocalSource = this.isLocalSource()
+    const isSentToProxy = this.state.destination !== sendTo
+    this.log.verbose('isLocalSource and isSentToProxy: ', { isLocalSource, isSentToProxy })
+
+    if (isSentToProxy && isLocalSource) {
+      this.stepInProgress('#setProxyGetPartiesTimeout')
+      const { source, proxy } = this.state
+      const alsReq = this.deps.partiesUtils.alsRequestDto(source, this.inputs.params)
+      const isSet = await this.deps.proxyCache.setProxyGetPartiesTimeout(alsReq, proxy)
+      this.log.info('#setProxyGetPartiesTimeout is done', { isSet })
+      return isSet
+    }
   }
 }
 
 module.exports = GetPartiesService
+
+// As Payee DFSP Scheme Oracle identifies direct participant.
+// As Payer DFSP Scheme oracle identifies interscheme participant.
+
+// zm-dfsp --> ZM
+// region-dfsp --> Region
+// mw-dfsp --> MW  (mw-party-123)
+
+// 1. region-dfsp gets info about mw-party-123

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

@@ -39,6 +39,7 @@ class PutPartiesErrorService extends BasePartiesService {
         // 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.removeProxyGetPartiesTimeout(alsReq)
         return true // need to trigger inter-scheme discovery
       }
 

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

@@ -49,8 +49,8 @@ class PutPartiesService extends BasePartiesService {
     const log = this.log.child({ source, proxy, method: 'validateSourceParticipant' })
     this.stepInProgress('validateSourceParticipant-1')
 
-    const requesterParticipant = await super.validateParticipant(source)
-    if (!requesterParticipant) {
+    const schemeParticipant = await super.validateParticipant(source)
+    if (!schemeParticipant) {
       if (!proxyEnabled || !proxy) {
         throw super.createFspiopIdNotFoundError(ERROR_MESSAGES.sourceFspNotFound, log)
       }
@@ -72,12 +72,16 @@ class PutPartiesService extends BasePartiesService {
       const alsReq = this.deps.partiesUtils.alsRequestDto(destination, params)
 
       const isExists = await this.deps.proxyCache.receivedSuccessResponse(alsReq)
-      if (isExists) {
-        await this.#updateOracleWithParticipantMapping({ source, headers, params })
+      if (!isExists) {
+        this.log.verbose('NOT inter-scheme receivedSuccessResponse case')
+        await this.removeProxyGetPartiesTimeout(alsReq)
         return
       }
-      this.log.warn('destination is NOT in scheme, and no cached sendToProxiesList', { destination, alsReq })
-      // todo: think, if we need to throw an error here
+
+      const schemeParticipant = await super.validateParticipant(destination)
+      if (schemeParticipant) {
+        await this.#updateOracleWithParticipantMapping({ source, headers, params })
+      }
     }
   }
 

package/src/domain/timeout/index.js

@@ -52,6 +52,10 @@ const timeoutInterschemePartiesLookups = async ({ proxyCache, batchSize }) => {
   return proxyCache.processExpiredAlsKeys(sendTimeoutCallback, batchSize)
 }
 
+const timeoutProxyGetPartiesLookups = async ({ proxyCache, batchSize }) => {
+  return proxyCache.processExpiredProxyGetPartiesKeys(sendTimeoutCallback, batchSize)
+}
+
 const sendTimeoutCallback = async (cacheKey) => {
   const histTimerEnd = Metrics.getHistogram(
     'eg_timeoutInterschemePartiesLookups',
@@ -59,7 +63,7 @@ const sendTimeoutCallback = async (cacheKey) => {
     ['success']
   ).startTimer()
   let step
-  const [, destination, partyType, partyId] = cacheKey.split(':')
+  const [destination, partyType, partyId] = parseCacheKey(cacheKey)
   const { errorInformation, params, headers, endpointType, span } = await timeoutCallbackDto({ destination, partyId, partyType })
   logger.debug('sendTimeoutCallback details:', { destination, partyType, partyId, cacheKey })
 
@@ -103,7 +107,13 @@ const finishSpan = async (span, err) => {
   }
 }
 
+const parseCacheKey = (cacheKey) => {
+  const [destination, partyType, partyId] = cacheKey.split(':').slice(-3)
+  return [destination, partyType, partyId]
+}
+
 module.exports = {
   timeoutInterschemePartiesLookups,
+  timeoutProxyGetPartiesLookups,
   sendTimeoutCallback // Exposed for testing
 }

package/src/handlers/TimeoutHandler.js

@@ -41,13 +41,13 @@ let isRunning
 
 const timeout = async (options) => {
   if (isRunning) return
-
   const { logger } = options
 
   try {
     isRunning = true
-    logger.debug('Timeout handler triggered')
     await TimeoutService.timeoutInterschemePartiesLookups(options)
+    await TimeoutService.timeoutProxyGetPartiesLookups(options)
+    logger.verbose('ALS timeout handler is done')
   } catch (err) {
     logger.error('error in timeout: ', err)
   } finally {

package/src/lib/util.js

@@ -29,10 +29,11 @@ const util = require('node:util')
 const Path = require('node:path')
 const EventSdk = require('@mojaloop/event-sdk')
 const Enum = require('@mojaloop/central-services-shared').Enum
-const { HeaderValidation, Hapi } = require('@mojaloop/central-services-shared').Util
+const { HeaderValidation } = require('@mojaloop/central-services-shared').Util
 const rethrow = require('@mojaloop/central-services-shared').Util.rethrow.with('ALS')
 
 const Config = require('../lib/config')
+const { API_TYPES } = require('../constants')
 const { logger } = require('./index')
 
 const getSpanTags = ({ headers }, transactionType, transactionAction) => {
@@ -69,7 +70,7 @@ const pathForInterface = ({ isAdmin, isMockInterface }) => {
     if (isMockInterface) {
       apiFile = 'api_swagger.json'
     } else {
-      apiFile = Config.API_TYPE === Hapi.API_TYPES.iso20022
+      apiFile = Config.API_TYPE === API_TYPES.iso20022
         ? 'api-swagger-iso20022-parties.yaml'
         : 'api-swagger.yaml'
     }
@@ -100,7 +101,14 @@ const countFspiopError = (error, options) => {
   rethrow.countFspiopError(error, options)
 }
 
-// todo: think better name
+/**
+ *  An immutable object representing the step state
+ * @typedef {Object} StepState
+ * @property {string} step - The current step value (read-only getter property)
+ * @property {(string) => void} inProgress - Method to update the current step
+ */
+
+/** @returns {StepState} */
 const initStepState = (initStep = 'start') => {
   let step = initStep
   return Object.freeze({

package/test/unit/domain/participants/participants.test.js

@@ -1369,7 +1369,7 @@ describe('participant Tests', () => {
 
       // Assert
       expect(logStub.getCall(0).firstArg).toBe(ERROR_MESSAGES.sourceFspNotFound)
-      expect(logStub.getCall(2).lastArg).toEqual(cbError)
+      expect(logStub.getCall(3).lastArg).toEqual(cbError)
     })
 
     it('handles error when `oracleBatchRequest` returns no result', async () => {

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

@@ -248,7 +248,7 @@ describe('Parties Tests', () => {
       await partiesDomain.getPartiesByTypeAndID(Helper.getByTypeIdRequest.headers, Helper.getByTypeIdRequest.params, Helper.getByTypeIdRequest.method, Helper.getByTypeIdRequest.query)
 
       // Assert
-      expect(loggerStub.callCount).toBe(1)
+      expect(loggerStub.callCount).toBe(2)
       expect(participant.sendErrorToParticipant.callCount).toBe(1)
 
       const { errorInformation } = participant.sendErrorToParticipant.getCall(0).args[2]
@@ -481,7 +481,7 @@ describe('Parties Tests', () => {
       })
       sandbox.stub(oracle, 'oracleRequest').resolves(oracleResponse)
       participant.validateParticipant = sandbox.stub()
-        .onFirstCall().resolves({}) // source
+        .onFirstCall().resolves(null) // source
         .onSecondCall().resolves(null) // oracle dfsp
       participant.sendRequest = sandbox.stub().resolves()
       participant.sendErrorToParticipant = sandbox.stub().resolves()
@@ -490,7 +490,7 @@ describe('Parties Tests', () => {
       expect(isAdded).toBe(true)
 
       const source = `fromDfsp-${Date.now()}`
-      const headers = fixtures.partiesCallHeadersDto({ destination: '', source })
+      const headers = fixtures.partiesCallHeadersDto({ destination: '', source, proxy: 'proxy' })
       const { params, method, query } = Helper.getByTypeIdRequest
 
       await partiesDomain.getPartiesByTypeAndID(headers, params, method, query, null, null, proxyCache)
@@ -901,7 +901,7 @@ describe('Parties Tests', () => {
 
       // Assert
       expect(participant.sendErrorToParticipant.callCount).toBe(1)
-      expect(loggerStub.callCount).toBe(1)
+      expect(loggerStub.callCount).toBe(2)
       const sendErrorCallArgs = participant.sendErrorToParticipant.getCall(0).args
       expect(sendErrorCallArgs[1]).toBe(expectedCallbackEnpointType)
     })
@@ -922,7 +922,7 @@ describe('Parties Tests', () => {
 
       // Assert
       expect(participant.sendErrorToParticipant.callCount).toBe(1)
-      expect(loggerStub.callCount).toBe(1)
+      expect(loggerStub.callCount).toBe(2)
       const sendErrorCallArgs = participant.sendErrorToParticipant.getCall(0).args
       expect(sendErrorCallArgs[1]).toBe(expectedCallbackEnpointType)
     })

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

@@ -0,0 +1,51 @@
+/*****
+ License
+ --------------
+ Copyright © 2020-2025 Mojaloop Foundation
+ The Mojaloop files are made available by the Mojaloop Foundation under the Apache License, Version 2.0 (the "License") and you may not use these files except in compliance with the License. You may obtain a copy of the License at
+ http://www.apache.org/licenses/LICENSE-2.0
+ Unless required by applicable law or agreed to in writing, the Mojaloop files are distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+
+ Contributors
+ --------------
+ This is the official list of the Mojaloop project contributors for this file.
+ Names of the original copyright holders (individuals or organizations)
+ should be listed with a '*' in the first column. People who have
+ contributed from an organization can be listed under the organization
+ that actually holds the copyright for their contributions (see the
+ Mojaloop Foundation organization for an example). Those individuals should have
+ their names indented and be marked with a '-'. Email address can be added
+ optionally within square brackets <email>.
+ * Mojaloop Foundation
+ - Name Surname <name.surname@mojaloop.io>
+
+ * Eugen Klymniuk <eugen.klymniuk@infitx.com>
+ --------------
+ **********/
+
+const ErrorHandler = require('@mojaloop/central-services-error-handling')
+const partiesUtils = require('#src/domain/parties/partiesUtils')
+const config = require('#src/lib/config')
+const { API_TYPES } = require('#src/constants')
+const fixtures = require('#test/fixtures/index')
+
+describe('partiesUtils Tests -->', () => {
+  describe('makePutPartiesErrorPayload Tests', () => {
+    const error = ErrorHandler.Factory.reformatFSPIOPError(new Error('Test Error'))
+    const ERR_CODE = '2001'
+    const headers = fixtures.partiesCallHeadersDto()
+    const params = fixtures.partiesParamsDto()
+
+    test('should make putParties error payload in FSPIOP format', async () => {
+      const fspiopConfig = { ...config, API_TYPE: API_TYPES.fspiop }
+      const payload = await partiesUtils.makePutPartiesErrorPayload(fspiopConfig, error, headers, params)
+      expect(payload.errorInformation.errorCode).toBe(ERR_CODE)
+    })
+
+    test('should make putParties error payload in ISO20022 format', async () => {
+      const fspiopConfig = { ...config, API_TYPE: API_TYPES.iso20022 }
+      const payload = await partiesUtils.makePutPartiesErrorPayload(fspiopConfig, error, headers, params)
+      expect(payload.Rpt.Rsn.Cd).toBe(ERR_CODE)
+    })
+  })
+})

package/test/unit/domain/parties/{utils.test.js → services/BasePartiesService.test.js}

@@ -3,7 +3,9 @@
  --------------
  Copyright © 2020-2025 Mojaloop Foundation
  The Mojaloop files are made available by the Mojaloop Foundation under the Apache License, Version 2.0 (the "License") and you may not use these files except in compliance with the License. You may obtain a copy of the License at
+
  http://www.apache.org/licenses/LICENSE-2.0
+
  Unless required by applicable law or agreed to in writing, the Mojaloop files are distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
 
  Contributors
@@ -13,46 +15,43 @@
  should be listed with a '*' in the first column. People who have
  contributed from an organization can be listed under the organization
  that actually holds the copyright for their contributions (see the
- Mojaloop Foundation organization for an example). Those individuals should have
+ Mojaloop Foundation for an example). Those individuals should have
  their names indented and be marked with a '-'. Email address can be added
  optionally within square brackets <email>.
- * Mojaloop Foundation
- - Name Surname <name.surname@mojaloop.io>
 
+ * Mojaloop Foundation
  * Eugen Klymniuk <eugen.klymniuk@infitx.com>
- --------------
- **********/
-
-const mockSendRequest = jest.fn()
-
-jest.mock('@mojaloop/central-services-shared', () => ({
-  ...jest.requireActual('@mojaloop/central-services-shared'),
-  Util: {
-    ...jest.requireActual('@mojaloop/central-services-shared').Util,
-    Endpoints: { getEndpoint: jest.fn() },
-    Request: { sendRequest: mockSendRequest }
-  }
-}))
-
-const { API_TYPES } = require('@mojaloop/central-services-shared').Util.Hapi
-const { logger } = require('../../../../src/lib')
-const partiesUtils = require('../../../../src/domain/parties/partiesUtils')
-const config = require('../../../../src/lib/config')
-const fixtures = require('../../../fixtures')
-
-describe('parties utils Tests -->', () => {
-  test('should send error party callback in ISO format', async () => {
-    const isoConfig = { ...config, API_TYPE: API_TYPES.iso20022 }
-    const err = new Error('test error')
-    const source = 'dfsp1'
-    const headers = fixtures.partiesCallHeadersDto({ source })
-    const params = { ID: '1234', Type: 'MSISDN' }
 
-    const handleError = partiesUtils.createErrorHandlerOnSendingCallback(isoConfig, logger)
-    await handleError(err, headers, params, source)
+ --------------
+ ******/
+
+const { createMockDeps, participantMock } = require('./deps')
+// should be first require to mock external deps
+const BasePartiesService = require('#src/domain/parties/services/BasePartiesService')
+const config = require('#src/lib/config')
+const { API_TYPES } = require('#src/constants')
+const fixtures = require('#test/fixtures/index')
+
+describe('BasePartiesService Tests -->', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
 
-    expect(mockSendRequest).toHaveBeenCalledTimes(1)
-    const { payload } = mockSendRequest.mock.calls[0][0]
+  test('should send error party callback in ISO20022 format', async () => {
+    const deps = {
+      ...createMockDeps(),
+      config: { ...config, API_TYPE: API_TYPES.iso20022 }
+    }
+    const source = 'sourceFsp'
+    const headers = fixtures.partiesCallHeadersDto({ source })
+    const params = fixtures.partiesParamsDto()
+    const service = new BasePartiesService(deps, { headers, params })
+
+    await service.handleError(new Error('test error'))
+    expect(participantMock.sendErrorToParticipant.mock.calls.length).toBe(1)
+    // eslint-disable-next-line no-unused-vars
+    const [sentTo, _, payload] = participantMock.sendErrorToParticipant.mock.lastCall
+    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)

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

@@ -25,15 +25,10 @@
  --------------
  ******/
 
-jest.mock('#src/models/oracle/facade')
-jest.mock('#src/models/participantEndpoint/facade')
-
+const { createMockDeps, createProxyCacheMock, oracleMock, participantMock } = require('./deps')
+// should be first require to mock external deps
 const { GetPartiesService } = require('#src/domain/parties/services/index')
-const { ERROR_MESSAGES } = require('#src/constants')
-const oracle = require('#src/models/oracle/facade')
-const participant = require('#src/models/participantEndpoint/facade')
 const fixtures = require('#test/fixtures/index')
-const { createMockDeps, createProxyCacheMock } = require('./deps')
 
 const { RestMethods, Headers } = GetPartiesService.enums()
 
@@ -44,7 +39,7 @@ describe('GetPartiesService Tests -->', () => {
 
   describe('forwardRequestToDestination method', () => {
     test('should delete party info from oracle, if no destination DFSP in proxy mapping', async () => {
-      participant.validateParticipant = jest.fn().mockResolvedValueOnce(false)
+      participantMock.validateParticipant = jest.fn().mockResolvedValueOnce(null)
       const proxyCache = createProxyCacheMock({
         lookupProxyByDfspId: jest.fn().mockResolvedValueOnce(null)
       })
@@ -58,8 +53,8 @@ describe('GetPartiesService Tests -->', () => {
 
       await service.forwardRequestToDestination()
 
-      expect(oracle.oracleRequest.mock.calls.length).toBe(1)
-      const [sentHeaders, method, sentParams] = oracle.oracleRequest.mock.lastCall
+      expect(oracleMock.oracleRequest.mock.calls.length).toBe(1)
+      const [sentHeaders, method, sentParams] = oracleMock.oracleRequest.mock.lastCall
       expect(method).toBe(RestMethods.DELETE)
       expect(sentHeaders).toEqual(headers)
       expect(sentParams).toEqual(params)
@@ -79,10 +74,10 @@ describe('GetPartiesService Tests -->', () => {
     let proxyCache
 
     beforeEach(async () => {
-      oracle.oracleRequest = jest.fn().mockResolvedValueOnce(
+      oracleMock.oracleRequest = jest.fn().mockResolvedValueOnce(
         fixtures.oracleRequestResponseDto({ partyList: [{ fspId: EXTERNAL_DFSP_ID }] })
       )
-      participant.validateParticipant = jest.fn()
+      participantMock.validateParticipant = jest.fn()
         .mockResolvedValueOnce(null) // source
         .mockResolvedValueOnce({}) // proxy
 
@@ -93,50 +88,135 @@ describe('GetPartiesService Tests -->', () => {
       deps = createMockDeps({ proxyCache })
     })
 
-    test('should throw ID_NOT_FOUND error and cleanup oracle, if no proxyMapping for external dfsp', async () => {
-      expect.hasAssertions()
+    test('should cleanup oracle and trigger interScheme discovery, if no proxyMapping for external dfsp', async () => {
       proxyCache.lookupProxyByDfspId = jest.fn().mockResolvedValueOnce(null)
       const headers = fixtures.partiesCallHeadersDto({
         destination: '', proxy: 'proxyA'
       })
       const params = fixtures.partiesParamsDto()
       const service = new GetPartiesService(deps, { headers, params })
+      service.triggerInterSchemeDiscoveryFlow = jest.fn()
 
       await service.handleRequest()
-        .catch((err) => {
-          expect(err).toEqual(service.createFspiopIdNotFoundError(ERROR_MESSAGES.noDiscoveryRequestsForwarded))
-        })
-      expect(oracle.oracleRequest.mock.calls.length).toBe(2) // GET + DELETE
-      expect(oracle.oracleRequest.mock.lastCall[1]).toBe(RestMethods.DELETE)
+      expect(oracleMock.oracleRequest).toHaveBeenCalledTimes(2) // GET + DELETE
+      expect(oracleMock.oracleRequest.mock.lastCall[1]).toBe(RestMethods.DELETE)
+      expect(service.triggerInterSchemeDiscoveryFlow).toHaveBeenCalledWith(headers)
     })
 
-    test('should throw ID_NOT_FOUND error, if source is external', async () => {
-      expect.hasAssertions()
+    test('should trigger interScheme discovery flow, if source is external', async () => {
       const headers = fixtures.partiesCallHeadersDto({
         destination: '', proxy: 'proxyA'
       })
       const params = fixtures.partiesParamsDto()
       const service = new GetPartiesService(deps, { headers, params })
+      service.triggerInterSchemeDiscoveryFlow = jest.fn()
 
       await service.handleRequest()
-        .catch((err) => {
-          expect(err).toEqual(service.createFspiopIdNotFoundError(ERROR_MESSAGES.noDiscoveryRequestsForwarded))
-        })
+      expect(service.triggerInterSchemeDiscoveryFlow).toHaveBeenCalledWith(headers)
     })
 
-    test('should forward request, if source is in scheme', async () => {
-      participant.validateParticipant = jest.fn(async (fsp) => (fsp === EXTERNAL_DFSP_ID ? null : {}))
+    test('should forward request, if source is in scheme (no proxy header)', async () => {
+      participantMock.validateParticipant = jest.fn(async (fsp) => (fsp === EXTERNAL_DFSP_ID ? null : {}))
       const headers = fixtures.partiesCallHeadersDto({
-        destination: '', proxy: 'proxyA'
+        destination: '', proxy: ''
       })
       const params = fixtures.partiesParamsDto()
       const service = new GetPartiesService(deps, { headers, params })
 
       await service.handleRequest()
-      expect(participant.sendRequest.mock.calls.length).toBe(1)
-      const [sentHeaders, sendTo] = participant.sendRequest.mock.lastCall
+      expect(participantMock.sendRequest.mock.calls.length).toBe(1)
+      const [sentHeaders, sendTo] = participantMock.sendRequest.mock.lastCall
       expect(sendTo).toEqual(PROXY_ID)
       expect(sentHeaders[Headers.FSPIOP.DESTINATION]).toBe(EXTERNAL_DFSP_ID)
     })
+
+    test('should trigger inter-scheme discovery flow, if source is NOT in scheme', async () => {
+      const source = 'test-zm-dfsp'
+      const proxyZm = 'proxy-zm'
+      participantMock.validateParticipant = jest.fn(
+        async (fsp) => ([EXTERNAL_DFSP_ID, source].includes(fsp) ? null : {})
+      )
+      deps.proxies.getAllProxiesNames = jest.fn().mockResolvedValueOnce([PROXY_ID, proxyZm])
+      const headers = fixtures.partiesCallHeadersDto({
+        source, destination: '', proxy: proxyZm
+      })
+      const params = fixtures.partiesParamsDto()
+      const service = new GetPartiesService(deps, { headers, params })
+
+      await service.handleRequest()
+      expect(participantMock.sendRequest).toHaveBeenCalledTimes(1)
+      const [sentHeaders, sendTo] = participantMock.sendRequest.mock.lastCall
+      expect(sendTo).toEqual(PROXY_ID)
+      expect(sentHeaders[Headers.FSPIOP.DESTINATION]).toBeUndefined()
+    })
+  })
+
+  describe('setProxyGetPartiesTimeout Tests', () => {
+    test('should set getParties timeout for local source and external destination', async () => {
+      participantMock.validateParticipant = jest.fn()
+        .mockResolvedValueOnce({}) // source
+        .mockResolvedValueOnce(null) // destination
+      const proxyCache = createProxyCacheMock({
+        lookupProxyByDfspId: jest.fn().mockResolvedValueOnce('proxy-dest')
+      })
+      const deps = createMockDeps({ proxyCache })
+      const headers = fixtures.partiesCallHeadersDto()
+      const params = fixtures.partiesParamsDto()
+      const service = new GetPartiesService(deps, { headers, params })
+
+      await service.handleRequest()
+      expect(proxyCache.setProxyGetPartiesTimeout).toHaveBeenCalledTimes(1)
+      expect(participantMock.sendRequest).toHaveBeenCalledTimes(1)
+    })
+
+    test('should NOT set getParties timeout if source is external', async () => {
+      participantMock.validateParticipant = jest.fn()
+        .mockResolvedValueOnce(null) // source
+        .mockResolvedValueOnce({}) // proxy-src
+      const proxyCache = createProxyCacheMock({
+        lookupProxyByDfspId: jest.fn().mockResolvedValue('proxy-desc')
+      })
+      const deps = createMockDeps({ proxyCache })
+      const headers = fixtures.partiesCallHeadersDto({ proxy: 'proxy-src' })
+      const params = fixtures.partiesParamsDto()
+      const service = new GetPartiesService(deps, { headers, params })
+
+      await service.handleRequest()
+      expect(proxyCache.setProxyGetPartiesTimeout).not.toHaveBeenCalled()
+      expect(participantMock.sendRequest).toHaveBeenCalledTimes(1)
+    })
+
+    test('should NOT set getParties timeout if destination is local', async () => {
+      participantMock.validateParticipant = jest.fn().mockResolvedValue({})
+      const proxyCache = createProxyCacheMock()
+      const deps = createMockDeps({ proxyCache })
+      const headers = fixtures.partiesCallHeadersDto()
+      const params = fixtures.partiesParamsDto()
+      const service = new GetPartiesService(deps, { headers, params })
+
+      await service.handleRequest()
+      expect(proxyCache.setProxyGetPartiesTimeout).not.toHaveBeenCalled()
+      expect(participantMock.sendRequest).toHaveBeenCalledTimes(1)
+    })
+
+    test('should set getParties timeout if oracle returns external participant', async () => {
+      participantMock.validateParticipant = jest.fn()
+        .mockResolvedValueOnce({}) // source
+        .mockResolvedValueOnce(null) // externalDfsp
+      oracleMock.oracleRequest = jest.fn(async () => fixtures.oracleRequestResponseDto({
+        partyList: [{ fspId: 'externalDfsp' }]
+      }))
+      const proxyCache = createProxyCacheMock({
+        lookupProxyByDfspId: jest.fn().mockResolvedValue('proxyExternal')
+      })
+      const deps = createMockDeps({ proxyCache })
+      const headers = fixtures.partiesCallHeadersDto({ destination: '' })
+      const params = fixtures.partiesParamsDto()
+      const service = new GetPartiesService(deps, { headers, params })
+
+      await service.handleRequest()
+      expect(proxyCache.setProxyGetPartiesTimeout).toHaveBeenCalledTimes(1)
+      expect(participantMock.sendRequest).toHaveBeenCalledTimes(1)
+    })
   })
 })

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

@@ -25,13 +25,9 @@
  --------------
  ******/
 
-jest.mock('#src/models/oracle/facade')
-jest.mock('#src/models/participantEndpoint/facade')
-
+const { createMockDeps, oracleMock } = require('./deps')
 const { PutPartiesErrorService } = require('#src/domain/parties/services/index')
-const oracle = require('#src/models/oracle/facade')
 const fixtures = require('#test/fixtures/index')
-const { createMockDeps } = require('./deps')
 
 const { RestMethods } = PutPartiesErrorService.enums()
 
@@ -47,7 +43,7 @@ describe('PutPartiesErrorService Tests -->', () => {
 
     const needDiscovery = await service.handleRequest()
     expect(needDiscovery).toBe(true)
-    expect(oracle.oracleRequest.mock.calls.length).toBe(1)
-    expect(oracle.oracleRequest.mock.lastCall[1]).toBe(RestMethods.DELETE)
+    expect(oracleMock.oracleRequest.mock.calls.length).toBe(1)
+    expect(oracleMock.oracleRequest.mock.lastCall[1]).toBe(RestMethods.DELETE)
   })
 })

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

@@ -25,16 +25,25 @@
  --------------
  ******/
 
+jest.mock('#src/models/oracle/facade')
+jest.mock('#src/models/participantEndpoint/facade')
+
+const oracleMock = require('#src/models/oracle/facade')
+const participantMock = require('#src/models/participantEndpoint/facade')
 const { createDeps } = require('#src/domain/parties/deps')
 const { logger } = require('#src/lib/index')
 const { createProxyCacheMock } = require('#test/util/mockDeps')
 
+/** @returns {PartiesDeps} */
 const createMockDeps = ({
   proxyCache = createProxyCacheMock(),
-  log = logger.child({ test: true })
-} = {}) => createDeps({ proxyCache, log })
+  log = logger.child({ test: true }),
+  cache
+} = {}) => createDeps({ cache, proxyCache, log })
 
 module.exports = {
   createMockDeps,
-  createProxyCacheMock
+  createProxyCacheMock,
+  oracleMock,
+  participantMock
 }

package/test/unit/domain/timeout/index.test.js

@@ -64,16 +64,16 @@ describe('Timeout Domain', () => {
 
     describe('sendTimeoutCallback', () => {
       it('should send error to participant', async () => {
-        jest.spyOn(Participant, 'validateParticipant').mockResolvedValue({ fspId: 'sourceId' })
+        const SOURCE_ID = 'sourceId'
+        jest.spyOn(Participant, 'validateParticipant').mockResolvedValue({ fspId: SOURCE_ID })
 
-        const cacheKey = 'als:sourceId:2:3:expiresAt'
-        const [, destination] = cacheKey.split(':')
+        const cacheKey = `als:${SOURCE_ID}:2:3` // ':expiresAt' part is removed inside proxyCache.processExpiryKey()
 
         await TimeoutDomain.sendTimeoutCallback(cacheKey)
 
-        expect(Participant.validateParticipant).toHaveBeenCalledWith('sourceId')
+        expect(Participant.validateParticipant).toHaveBeenCalledWith(SOURCE_ID)
         expect(Participant.sendErrorToParticipant).toHaveBeenCalledWith(
-          destination,
+          SOURCE_ID,
           'FSPIOP_CALLBACK_URL_PARTIES_PUT_ERROR',
           { errorInformation: { errorCode: '3300', errorDescription: 'Generic expired error' } },
           expect.any(Object), expect.any(Object), undefined, expect.any(Object)

package/test/util/mockDeps.js

@@ -32,6 +32,8 @@ const createProxyCacheMock = ({
   receivedErrorResponse = jest.fn(async () => false),
   receivedSuccessResponse = jest.fn(async () => true),
   removeDfspIdFromProxyMapping = jest.fn(async () => true),
+  removeProxyGetPartiesTimeout = jest.fn(async () => true),
+  setProxyGetPartiesTimeout = jest.fn(async () => true),
   setSendToProxiesList = jest.fn(async () => true)
 } = {}) => ({
   addDfspIdToProxyMapping,
@@ -40,6 +42,8 @@ const createProxyCacheMock = ({
   receivedErrorResponse,
   receivedSuccessResponse,
   removeDfspIdFromProxyMapping,
+  removeProxyGetPartiesTimeout,
+  setProxyGetPartiesTimeout,
   setSendToProxiesList
 })