account-lookup-service 17.12.10 → 17.13.0-snapshot.10

package/src/constants.js

@@ -29,7 +29,7 @@ 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
+  externalPartyError: 'External party resolution error',
   failedToCacheSendToProxiesList: 'Failed to cache sendToProxiesList',
   noDiscoveryRequestsForwarded: 'No discovery requests forwarded to participants',
   sourceFspNotFound: 'Requester FSP not found',

package/src/domain/parties/deps.js

@@ -28,8 +28,8 @@
 const { Util } = require('@mojaloop/central-services-shared')
 const { logger } = require('../../lib')
 const config = require('../../lib/config')
-const oracle = require('../../models/oracle/facade')
-const participant = require('../../models/participantEndpoint/facade')
+const oracleFacade = require('../../models/oracle/facade')
+const participantFacade = require('../../models/participantEndpoint/facade')
 const partiesUtils = require('./partiesUtils')
 
 /** @returns {PartiesDeps} */
@@ -37,6 +37,8 @@ const createDeps = ({
   cache,
   proxyCache,
   proxies = Util.proxies,
+  participant = participantFacade,
+  oracle = oracleFacade,
   childSpan = null,
   log = logger
 }) => Object.freeze({
@@ -44,10 +46,10 @@ const createDeps = ({
   proxyCache,
   childSpan,
   log,
-  config,
   oracle,
-  participant,
   proxies,
+  participant,
+  config,
   partiesUtils
 })
 

package/src/domain/parties/putParties.js

@@ -47,7 +47,7 @@ const services = require('./services')
  * @param {IProxyCache} [proxyCache] - IProxyCache instance
  */
 const putPartiesByTypeAndID = async (headers, params, method, payload, dataUri, cache, proxyCache = undefined) => {
-  // todo: think, if we need to pass span here
+  // think, if we need to pass span here
   const component = putPartiesByTypeAndID.name
   const histTimerEnd = Metrics.getHistogram(
     component,

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

@@ -26,12 +26,10 @@
  ******/
 
 const ErrorHandler = require('@mojaloop/central-services-error-handling')
-const { Enum } = require('@mojaloop/central-services-shared')
-const { decodePayload } = require('@mojaloop/central-services-shared').Util.StreamingProtocol
+const { Enum, Util } = require('@mojaloop/central-services-shared')
 const { initStepState } = require('../../../lib/util')
 const { createCallbackHeaders } = require('../../../lib/headers')
 const { ERROR_MESSAGES } = require('../../../constants')
-const { makeAcceptContentTypeHeader } = require('@mojaloop/central-services-shared').Util.Headers
 
 const { FspEndpointTypes, FspEndpointTemplates } = Enum.EndPoints
 const { Headers, RestMethods, HeaderResources } = Enum.Http
@@ -170,6 +168,26 @@ class BasePartiesService {
     this.log.info('sendErrorCallback is done', { sendTo, errorInfo })
   }
 
+  /**
+   * @returns {Promise<{ fspId: string, partySubIdOrType?: string }[]>} List of parties from oracle response
+   */
+  async sendOracleDiscoveryRequest () {
+    this.stepInProgress('#sendOracleDiscoveryRequest')
+    const { headers, params, query } = this.inputs
+
+    const response = await this.deps.oracle.oracleRequest(headers, RestMethods.GET, params, query, undefined, this.deps.cache)
+    this.log.verbose('oracle discovery raw response:', { response })
+
+    let { partyList } = response?.data || {}
+    if (!Array.isArray(partyList)) {
+      this.log.warn('invalid oracle discovery response:', { response })
+      // todo: maybe, it's better to throw an error
+      partyList = []
+    }
+
+    return partyList
+  }
+
   async sendDeleteOracleRequest (headers, params) {
     this.stepInProgress('sendDeleteOracleRequest')
     const result = await this.deps.oracle.oracleRequest(headers, RestMethods.DELETE, params, null, null, this.deps.cache)
@@ -184,6 +202,24 @@ class BasePartiesService {
     return isRemoved
   }
 
+  async sendPartyResolutionErrorCallback () {
+    this.stepInProgress('sendPartyResolutionErrorCallback')
+    const { headers, params } = this.inputs
+
+    const error = this.createFspiopPartyResolutionError(ERROR_MESSAGES.externalPartyError)
+    const callbackHeaders = BasePartiesService.createErrorCallbackHeaders(headers, params)
+    const errorInfo = await this.deps.partiesUtils.makePutPartiesErrorPayload(this.deps.config, error, callbackHeaders, params)
+    this.state.destination = callbackHeaders[Headers.FSPIOP.DESTINATION]
+
+    await this.identifyDestinationForCallback()
+    await this.sendErrorCallback({
+      errorInfo,
+      headers: callbackHeaders,
+      params
+    })
+    this.log.verbose('sendPartyResolutionErrorCallback is done', { callbackHeaders, errorInfo })
+  }
+
   createFspiopIdNotFoundError (errMessage, log = this.log) {
     log.warn(errMessage)
     return ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
@@ -194,9 +230,9 @@ class BasePartiesService {
     return ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.PARTY_NOT_FOUND, errMessage)
   }
 
-  createFspiopServiceUnavailableError (errMessage, log = this.log) {
+  createFspiopPartyResolutionError (errMessage, log = this.log) {
     log.warn(errMessage)
-    return ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.SERVICE_CURRENTLY_UNAVAILABLE, errMessage)
+    return ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.PARTY_RESOLUTION_FAILURE, errMessage)
   }
 
   stepInProgress (stepName) {
@@ -222,7 +258,7 @@ class BasePartiesService {
   }
 
   static decodeDataUriPayload (dataUri) {
-    const decoded = decodePayload(dataUri, { asParsed: false })
+    const decoded = Util.StreamingProtocol.decodePayload(dataUri, { asParsed: false })
     return decoded.body.toString()
   }
 
@@ -257,7 +293,7 @@ class BasePartiesService {
     return {
       [Headers.FSPIOP.SOURCE]: hubName,
       [Headers.FSPIOP.DESTINATION]: destination,
-      [Headers.GENERAL.CONTENT_TYPE.value]: makeAcceptContentTypeHeader(
+      [Headers.GENERAL.CONTENT_TYPE.value]: Util.Headers.makeAcceptContentTypeHeader(
         HeaderResources.PARTIES,
         config.PROTOCOL_VERSIONS.CONTENT.DEFAULT.toString(),
         config.API_TYPE

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

@@ -28,7 +28,7 @@
 const { ERROR_MESSAGES } = require('../../../constants')
 const BasePartiesService = require('./BasePartiesService')
 
-const { FspEndpointTypes, RestMethods } = BasePartiesService.enums()
+const { RestMethods } = BasePartiesService.enums()
 const proxyCacheTtlSec = 40 // todo: make configurable
 
 class GetPartiesService extends BasePartiesService {
@@ -45,8 +45,8 @@ class GetPartiesService extends BasePartiesService {
       return
     }
 
-    const response = await this.sendOracleDiscoveryRequest()
-    const isSent = await this.processOraclePartyListResponse(response)
+    const partyList = await this.sendOracleDiscoveryRequest()
+    const isSent = await this.processOraclePartyListResponse(partyList)
     this.log.info(`getParties request is ${isSent ? '' : 'NOT '}forwarded to oracle lookup DFSP`)
     if (isSent) return
 
@@ -63,7 +63,7 @@ class GetPartiesService extends BasePartiesService {
 
     const schemeSource = await this.validateParticipant(source)
     if (schemeSource) {
-      log.debug('source participant is in scheme')
+      log.verbose('source participant is in scheme')
       return source
     }
 
@@ -91,9 +91,9 @@ class GetPartiesService extends BasePartiesService {
     const log = this.log.child({ method: 'forwardRequestToDestination' })
     let sendTo = destination
 
-    const schemeParticipant = await this.validateParticipant(destination)
-    if (!schemeParticipant) {
-      this.stepInProgress('lookupProxyDestination-2')
+    const localParticipant = await this.validateParticipant(destination)
+    if (!localParticipant) {
+      this.stepInProgress('lookupProxyDestination')
       const proxyId = this.state.proxyEnabled && await this.deps.proxyCache.lookupProxyByDfspId(destination)
 
       if (!proxyId) {
@@ -103,26 +103,28 @@ class GetPartiesService extends BasePartiesService {
         return
       }
       sendTo = proxyId
+    } else {
+      // OSS-4203: Oracle validation for external source + local destination
+      const isValid = await this.#validateLocalDestinationForExternalSource()
+      if (!isValid) {
+        log.warn('incorrect destination from external source', { destination })
+        await this.sendPartyResolutionErrorCallback()
+        return
+      }
     }
 
     await this.#forwardGetPartiesRequest({ sendTo, headers, params })
     log.info('discovery getPartiesByTypeAndID request was sent', { sendTo })
   }
 
-  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 processOraclePartyListResponse (response) {
-    if (!Array.isArray(response?.data?.partyList) || response.data.partyList.length === 0) {
+  async processOraclePartyListResponse (rawPartyList) {
+    if (rawPartyList.length === 0) {
       this.log.verbose('oracle partyList is empty')
       return false
     }
 
     this.stepInProgress('processOraclePartyList')
-    const partyList = this.#filterOraclePartyList(response)
+    const partyList = this.#filterOraclePartyList(rawPartyList)
 
     let sentCount = 0
     await Promise.all(partyList.map(async party => {
@@ -166,28 +168,20 @@ class GetPartiesService extends BasePartiesService {
     return isLocal
   }
 
-  #filterOraclePartyList (response) {
+  #filterOraclePartyList (partyList) {
     // 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')
+    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) {
+    const filteredPartyList = !params?.SubId
+      ? partyList.filter(party => party.partySubIdOrType == null) // Filter records that DON'T contain a partySubIdOrType
+      : partyList.filter(party => party.partySubIdOrType === params.SubId) // Filter records that match partySubIdOrType
+
+    if (!filteredPartyList.length) {
       throw super.createFspiopIdNotFoundError(ERROR_MESSAGES.emptyFilteredPartyList)
     }
+    this.log.verbose('#filterOraclePartyList is done:', { filteredPartyList })
 
     return filteredPartyList
   }
@@ -321,6 +315,25 @@ class GetPartiesService extends BasePartiesService {
       return isSet
     }
   }
+
+  async #validateLocalDestinationForExternalSource () {
+    // this method is called ONLY for local destination
+    const { state, log } = this
+
+    const needValidation = state.requester !== state.source
+    log.verbose('needOracleValidation: ', { needValidation })
+    if (!needValidation) return true
+
+    const partyList = await this.sendOracleDiscoveryRequest()
+    if (partyList.length === 0) {
+      log.warn('Oracle returned empty party list')
+      return false
+    }
+
+    const isValid = partyList.some(party => party.fspId === state.destination)
+    log.verbose('#validateLocalDestinationForExternalSource is done', { isValid })
+    return isValid
+  }
 }
 
 module.exports = GetPartiesService

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

@@ -26,13 +26,13 @@
  ******/
 
 const BasePartiesService = require('./BasePartiesService')
-const { ERROR_MESSAGES } = require('../../../constants')
 
 class PutPartiesErrorService extends BasePartiesService {
   async handleRequest () {
     if (this.state.proxyEnabled && this.state.proxy) {
-      const alsReq = this.deps.partiesUtils.alsRequestDto(this.state.destination, this.inputs.params) // or source?
+      const alsReq = this.deps.partiesUtils.alsRequestDto(this.state.destination, this.inputs.params)
       const isInterSchemeDiscoveryCase = await this.deps.proxyCache.isPendingCallback(alsReq)
+      this.log.verbose(`isInterSchemeDiscoveryCase: ${isInterSchemeDiscoveryCase}`, this.state)
 
       if (isInterSchemeDiscoveryCase) {
         const isLast = await this.checkLastProxyCallback(alsReq)
@@ -41,13 +41,11 @@ class PutPartiesErrorService extends BasePartiesService {
           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')
+        const isExternal = await this.#isPartyFromExternalDfsp()
+        if (isExternal) {
+          this.log.info('need to cleanup oracle coz party is from external DFSP')
           await this.cleanupOracle()
-          await this.removeProxyGetPartiesTimeoutCache(alsReq)
-          await this.forwardServiceUnavailableErrorCallback()
-          return
+          await this.removeProxyGetPartiesTimeoutCache(alsReq) // think if we need this
         }
       }
     }
@@ -79,20 +77,18 @@ class PutPartiesErrorService extends BasePartiesService {
     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)
+  async #isPartyFromExternalDfsp () {
+    this.stepInProgress('#isPartyFromExternalDfsp')
+    const partyList = await super.sendOracleDiscoveryRequest()
+    if (!partyList.length) {
+      this.log.verbose('oracle returns empty partyList')
+      return false
+    }
+    // think, if we have several parties from oracle
+    const isExternal = !(await this.validateParticipant(partyList[0].fspId))
+    this.log.verbose('#isPartyFromExternalDfsp is done:', { isExternal, partyList })
 
-    await this.identifyDestinationForCallback()
-    await super.sendErrorCallback({
-      errorInfo,
-      headers: callbackHeaders,
-      params
-    })
-    this.log.verbose('#forwardServiceUnavailableErrorCallback is done', { callbackHeaders, errorInfo })
+    return isExternal
   }
 }
 

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

@@ -104,7 +104,7 @@ class PutPartiesService extends BasePartiesService {
       fspId: source
     }
     await this.deps.oracle.oracleRequest(headers, RestMethods.POST, params, null, mappingPayload, this.deps.cache)
-    this.log.info('oracle was updated with mappingPayload', { mappingPayload })
+    this.log.info('oracle was updated with mappingPayload: ', mappingPayload)
   }
 }
 

package/src/lib/headers.js

@@ -41,6 +41,7 @@ const Config = require('../lib/config')
  */
 exports.createCallbackHeaders = (params) => {
   const callbackHeaders = { ...params.requestHeaders }
+  delete callbackHeaders[Enums.Http.Headers.FSPIOP.PROXY]
 
   callbackHeaders[Enums.Http.Headers.FSPIOP.SOURCE] = Config.HUB_NAME
   callbackHeaders[Enums.Http.Headers.FSPIOP.DESTINATION] = params.requestHeaders[Enums.Http.Headers.FSPIOP.SOURCE]

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

@@ -947,6 +947,7 @@ describe('Parties Tests', () => {
       Config.PROXY_CACHE_CONFIG.enabled = true
       const errorCode = MojaloopApiErrorCodes.PAYEE_IDENTIFIER_NOT_VALID.code
       const payload = fixtures.errorCallbackResponseDto({ errorCode })
+      const dataUri = encodePayload(JSON.stringify(payload), 'application/json')
       const destination = `dest-${Date.now()}`
       const proxy = `proxy-${Date.now()}`
       const headers = fixtures.partiesCallHeadersDto({ destination, proxy })
@@ -958,11 +959,13 @@ describe('Parties Tests', () => {
       oracleEndpointCached.getOracleEndpointByType = sandbox.stub().resolves([
         { value: 'http://oracle.endpoint' }
       ])
-      oracle.oracleRequest = sandbox.stub().resolves()
+      oracle.oracleRequest = sandbox.stub().resolves({
+        data: { partyList: [{ fspId: 'fspId' }] }
+      })
 
-      await partiesDomain.putPartiesErrorByTypeAndID(headers, params, payload, '', null, null, proxyCache)
+      await partiesDomain.putPartiesErrorByTypeAndID(headers, params, payload, dataUri, null, null, proxyCache)
 
-      expect(oracle.oracleRequest.callCount).toBe(1)
+      expect(oracle.oracleRequest.callCount).toBe(2)
       expect(oracle.oracleRequest.lastCall.args[1]).toBe(RestMethods.DELETE)
       expect(participant.sendRequest.callCount).toBe(0)
       expect(participant.sendErrorToParticipant.callCount).toBe(1)
@@ -970,7 +973,7 @@ describe('Parties Tests', () => {
       const [sentTo, _, data, cbHeaders] = participant.sendErrorToParticipant.lastCall.args
       expect(sentTo).toBe(proxy)
       expect(cbHeaders[Headers.FSPIOP.DESTINATION]).toBe(destination)
-      expect(data.errorInformation.errorCode).toBe('2003')
+      expect(JSON.parse(data).errorInformation.errorCode).toBe(errorCode)
     })
   })
 })

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

@@ -28,10 +28,12 @@
 const { setTimeout: sleep } = require('node:timers/promises')
 const {
   createMockDeps,
+  createOracleFacadeMock,
+  createParticipantFacadeMock,
   createProxyCacheMock,
   createProxiesUtilMock,
-  oracleMock,
-  participantMock
+  oracleMock, // deprecated!  use createOracleFacadeMock instead
+  participantMock // deprecated!  use createParticipantFacadeMock instead
 } = require('./deps')
 // ↑ should be first require to mock external deps ↑
 const { GetPartiesService } = require('#src/domain/parties/services/index')
@@ -42,11 +44,16 @@ const { RestMethods, Headers } = GetPartiesService.enums()
 
 describe('GetPartiesService Tests -->', () => {
   const { config } = createMockDeps()
+  const { API_TYPE } = config
 
   beforeEach(() => {
     jest.clearAllMocks()
   })
 
+  afterEach(() => {
+    config.API_TYPE = API_TYPE // to avoid side effects
+  })
+
   describe('forwardRequestToDestination method', () => {
     test('should delete party info from oracle, if no destination DFSP in proxy mapping', async () => {
       participantMock.validateParticipant = jest.fn().mockResolvedValueOnce(null)
@@ -234,12 +241,14 @@ describe('GetPartiesService Tests -->', () => {
     })
 
     test('should send error callback in ISO format if proxyRequest failed after delay, and other proxies have already replied', async () => {
+      participantMock.validateParticipant = jest.fn().mockResolvedValue({})
       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')
     })
@@ -325,12 +334,181 @@ describe('GetPartiesService Tests -->', () => {
     }
     const headers = fixtures.partiesCallHeadersDto({ destination: '' })
     const params = fixtures.partiesParamsDto()
-    const service = new GetPartiesService(deps, { headers, params })
 
+    const service = new GetPartiesService(deps, { headers, params })
     await service.handleRequest()
+
     expect(participantMock.sendErrorToParticipant).toHaveBeenCalledTimes(1)
     const isoPayload = participantMock.sendErrorToParticipant.mock.lastCall[2]
     expect(isoPayload.Assgnmt).toBeDefined()
     expect(isoPayload.Rpt).toBeDefined()
   })
+
+  describe('OSS-4203: oracle validation for external source + local destination', () => {
+    const EXTERNAL_SOURCE_DFSP = 'externalSourceDfsp'
+    const LOCAL_DESTINATION_DFSP = 'localDestinationDfsp'
+    const ORACLE_DFSP_DIFFERENT = 'differentDfsp'
+    const PROXY_ID = 'proxyForExternal'
+
+    let deps
+    let oracle // facade
+    let participant // facade
+    let proxyCache
+    let headers
+    let params
+
+    beforeEach(() => {
+      oracle = createOracleFacadeMock()
+      participant = createParticipantFacadeMock()
+      proxyCache = createProxyCacheMock({
+        addDfspIdToProxyMapping: jest.fn().mockResolvedValueOnce(true)
+      })
+      deps = createMockDeps({ oracle, participant, proxyCache })
+      headers = fixtures.partiesCallHeadersDto({
+        source: EXTERNAL_SOURCE_DFSP,
+        destination: LOCAL_DESTINATION_DFSP,
+        proxy: PROXY_ID
+      })
+      params = fixtures.partiesParamsDto()
+    })
+
+    test('should forward request when oracle DFSP matches destination DFSP', async () => {
+      participant.validateParticipant = jest.fn()
+        .mockResolvedValueOnce(null) // external source (validateRequester)
+        .mockResolvedValueOnce({}) // proxy exists (validateRequester)
+        .mockResolvedValueOnce({}) // local destination (forwardRequestToDestination)
+        .mockResolvedValueOnce(null) // external source (shouldValidateViaOracle)
+        .mockResolvedValueOnce({}) // local destination (shouldValidateViaOracle)
+      oracle.oracleRequest = jest.fn().mockResolvedValueOnce(
+        fixtures.oracleRequestResponseDto({
+          partyList: [{ fspId: LOCAL_DESTINATION_DFSP }]
+        })
+      )
+
+      const service = new GetPartiesService(deps, { headers, params })
+      await service.handleRequest()
+
+      expect(oracle.oracleRequest).toHaveBeenCalledWith(
+        headers,
+        RestMethods.GET,
+        params,
+        undefined,
+        undefined,
+        deps.cache
+      )
+      expect(participant.sendRequest).toHaveBeenCalledWith(
+        expect.objectContaining({
+          [Headers.FSPIOP.DESTINATION]: LOCAL_DESTINATION_DFSP
+        }),
+        LOCAL_DESTINATION_DFSP,
+        expect.any(String),
+        RestMethods.GET,
+        undefined,
+        expect.any(Object),
+        null
+      )
+      expect(participant.sendErrorToParticipant).not.toHaveBeenCalled()
+    })
+
+    test('should send error callback when oracle DFSP differs from destination DFSP', async () => {
+      participant.validateParticipant = jest.fn()
+        .mockResolvedValueOnce(null) // external source (validateRequester)
+        .mockResolvedValueOnce({}) // proxy exists (validateRequester)
+        .mockResolvedValueOnce({}) // local destination (forwardRequestToDestination)
+        .mockResolvedValueOnce(null) // external source (shouldValidateViaOracle)
+        .mockResolvedValueOnce({})
+      oracle.oracleRequest = jest.fn().mockResolvedValueOnce(
+        fixtures.oracleRequestResponseDto({
+          partyList: [{ fspId: ORACLE_DFSP_DIFFERENT }]
+        })
+      )
+      proxyCache.lookupProxyByDfspId = jest.fn().mockResolvedValueOnce(PROXY_ID)
+
+      const service = new GetPartiesService(deps, { headers, params })
+      await service.handleRequest()
+
+      expect(oracle.oracleRequest).toHaveBeenCalledTimes(1)
+      expect(participant.sendErrorToParticipant).toHaveBeenCalledTimes(1)
+      expect(participant.sendRequest).not.toHaveBeenCalled()
+
+      const [sentTo, , errorPayload] = participant.sendErrorToParticipant.mock.lastCall
+      expect(sentTo).toBe(PROXY_ID) // Error is sent to the proxy (requester)
+      expect(errorPayload.errorInformation.errorCode).toBeDefined()
+    })
+
+    test('should send error callback when oracle returns empty result', async () => {
+      participant.validateParticipant = jest.fn()
+        .mockResolvedValueOnce(null) // external source (validateRequester)
+        .mockResolvedValueOnce({}) // proxy exists (validateRequester)
+        .mockResolvedValueOnce(null) // external source (shouldValidateViaOracle)
+        .mockResolvedValueOnce({}) // local destination (shouldValidateViaOracle)
+        .mockResolvedValueOnce({}) // local destination (forwardRequestToDestination)
+
+      oracle.oracleRequest = jest.fn().mockResolvedValueOnce(
+        fixtures.oracleRequestResponseDto({ partyList: [] })
+      )
+
+      const service = new GetPartiesService(deps, { headers, params })
+      await service.handleRequest()
+
+      expect(oracle.oracleRequest).toHaveBeenCalledTimes(1)
+      expect(participant.sendErrorToParticipant).toHaveBeenCalledTimes(1)
+      expect(participant.sendRequest).not.toHaveBeenCalled()
+    })
+
+    test('should skip oracle validation when source is local (not external)', async () => {
+      const headers = fixtures.partiesCallHeadersDto()
+      participant.validateParticipant = jest.fn().mockResolvedValue({})
+
+      const service = new GetPartiesService(deps, { headers, params })
+      await service.handleRequest()
+
+      expect(oracle.oracleRequest).not.toHaveBeenCalled()
+      expect(participant.sendRequest).toHaveBeenCalledTimes(1)
+    })
+
+    test('should skip oracle validation when destination is external (not local)', async () => {
+      const externalDestHeaders = fixtures.partiesCallHeadersDto({
+        source: EXTERNAL_SOURCE_DFSP,
+        destination: 'externalDestinationDfsp',
+        proxy: PROXY_ID
+      })
+      participant.validateParticipant = jest.fn()
+        .mockResolvedValueOnce(null) // external source
+        .mockResolvedValueOnce({}) // proxy exists
+        .mockResolvedValueOnce(null) // external destination
+      proxyCache.lookupProxyByDfspId = jest.fn().mockResolvedValueOnce(PROXY_ID)
+
+      const service = new GetPartiesService(deps, { headers: externalDestHeaders, params })
+      await service.handleRequest()
+
+      expect(oracle.oracleRequest).not.toHaveBeenCalled()
+      expect(participant.sendRequest).toHaveBeenCalledTimes(1)
+    })
+
+    test('should send error callback in ISO20022 format when API_TYPE is iso20022', async () => {
+      const isoConfig = { ...deps.config, API_TYPE: API_TYPES.iso20022 }
+      const isoDeps = { ...deps, config: isoConfig }
+
+      participant.validateParticipant = jest.fn()
+        .mockResolvedValueOnce(null) // external source (validateRequester)
+        .mockResolvedValueOnce({}) // proxy exists (validateRequester)
+        .mockResolvedValueOnce(null) // external source (shouldValidateViaOracle)
+        .mockResolvedValueOnce({}) // local destination (shouldValidateViaOracle)
+        .mockResolvedValueOnce({}) // local destination (forwardRequestToDestination)
+      oracle.oracleRequest = jest.fn().mockResolvedValueOnce(
+        fixtures.oracleRequestResponseDto({
+          partyList: [{ fspId: ORACLE_DFSP_DIFFERENT }]
+        })
+      )
+
+      const service = new GetPartiesService(isoDeps, { headers, params })
+      await service.handleRequest()
+
+      expect(participant.sendErrorToParticipant).toHaveBeenCalledTimes(1)
+      const isoPayload = participant.sendErrorToParticipant.mock.lastCall[2]
+      expect(isoPayload.Assgnmt).toBeDefined()
+      expect(isoPayload.Rpt).toBeDefined()
+    })
+  })
 })