account-lookup-service 17.4.1-csi-1300.1 → 17.4.1-csi-1300.3

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.4.1-csi-1300.1",
+  "version": "17.4.1-csi-1300.3",
   "license": "Apache-2.0",
   "author": "ModusBox",
   "contributors": [
@@ -97,7 +97,7 @@
     "@mojaloop/central-services-metrics": "12.4.5",
     "@mojaloop/central-services-shared": "18.22.4-snapshot.0",
     "@mojaloop/central-services-stream": "11.5.1",
-    "@mojaloop/database-lib": "11.1.3",
+    "@mojaloop/database-lib": "11.1.4",
     "@mojaloop/event-sdk": "14.3.2",
     "@mojaloop/inter-scheme-proxy-cache-lib": "2.3.7",
     "@mojaloop/ml-schema-transformer-lib": "2.5.8",

package/src/domain/parties/getPartiesByTypeAndID.js

@@ -61,8 +61,9 @@ const getPartiesByTypeAndID = async (headers, params, method, query, span, cache
     await service.handleRequest({ headers, params, query, results })
     log.info('getPartiesByTypeAndID is done')
     histTimerEnd({ success: true })
-  } catch (err) {
-    results.fspiopError = await deps.partiesUtils.createErrorHandlerOnSendingCallback(deps.config, log)(err, headers, params, results.requester)
+  } catch (error) {
+    const { requester } = results
+    results.fspiopError = await service.handleError({ error, requester, headers, params })
     histTimerEnd({ success: false })
     if (results.fspiopError) {
       libUtil.countFspiopError(results.fspiopError, { operation: component, step: stepState.step })

package/src/domain/parties/partiesUtils.js

@@ -26,6 +26,8 @@
  ******/
 
 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')
@@ -79,7 +81,7 @@ const swapSourceDestinationHeaders = (headers) => {
   }
 }
 
-// change signature to accept object
+// 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)
@@ -99,6 +101,10 @@ const createErrorHandlerOnSendingCallback = (config, logger) => async (err, head
   }
 }
 
+function isNotValidPayeeCase (payload) {
+  return payload?.errorInformation?.errorCode === MojaloopApiErrorCodes.PAYEE_IDENTIFIER_NOT_VALID.code
+}
+
 module.exports = {
   getPartyCbType,
   putPartyCbType,
@@ -107,5 +113,6 @@ module.exports = {
   createErrorHandlerOnSendingCallback,
   alsRequestDto,
   partiesRequestOptionsDto,
-  swapSourceDestinationHeaders
+  swapSourceDestinationHeaders,
+  isNotValidPayeeCase
 }

package/src/domain/parties/putParties.js

@@ -29,21 +29,15 @@
 
 'use strict'
 
-const { Headers, RestMethods } = require('@mojaloop/central-services-shared').Enum.Http
-const { decodePayload } = require('@mojaloop/central-services-shared').Util.StreamingProtocol
-const { MojaloopApiErrorCodes } = require('@mojaloop/sdk-standard-components').Errors
-const ErrorHandler = require('@mojaloop/central-services-error-handling')
+const { Headers } = require('@mojaloop/central-services-shared').Enum.Http
 const Metrics = require('@mojaloop/central-services-metrics')
 
-const oracle = require('../../models/oracle/facade')
-const participant = require('../../models/participantEndpoint/facade')
 const libUtil = require('../../lib/util')
 const Config = require('../../lib/config')
 const { logger } = require('../../lib')
-const { ERROR_MESSAGES } = require('../../constants')
 
-const partiesUtils = require('./partiesUtils')
-const getPartiesByTypeAndID = require('./getPartiesByTypeAndID')
+const services = require('./services')
+const { createDeps } = require('./deps')
 
 /**
  * @function putPartiesByTypeAndID
@@ -59,80 +53,44 @@ const getPartiesByTypeAndID = require('./getPartiesByTypeAndID')
  * @param {IProxyCache} [proxyCache] - IProxyCache instance
  */
 const putPartiesByTypeAndID = async (headers, params, method, payload, dataUri, cache, proxyCache = undefined) => {
-  const components = putPartiesByTypeAndID.name
+  // todo: think, if we need to pass span here
+  const component = putPartiesByTypeAndID.name
   const histTimerEnd = Metrics.getHistogram(
-    components,
+    component,
     'Put parties by type and id',
     ['success']
   ).startTimer()
-  const log = logger.child({ params, components })
+  // const childSpan = span ? span.getChild(component) : undefined
+  const log = logger.child({ component, params })
+  const stepState = libUtil.initStepState()
+
+  const deps = createDeps({ cache, proxyCache, log, stepState })
+  const service = new services.PutPartiesService(deps)
+  const results = {}
+
   const source = headers[Headers.FSPIOP.SOURCE]
   const destination = headers[Headers.FSPIOP.DESTINATION]
   const proxy = headers[Headers.FSPIOP.PROXY]
-  const proxyEnabled = !!(Config.PROXY_CACHE_CONFIG.enabled && proxyCache)
   log.info('parties::putPartiesByTypeAndID start', { source, destination, proxy })
 
-  let sendTo
-  let step
-
   try {
-    step = 'validateParticipant-1'
-    const requesterParticipant = await participant.validateParticipant(source)
-    if (!requesterParticipant) {
-      if (!proxyEnabled || !proxy) {
-        const errMessage = ERROR_MESSAGES.sourceFspNotFound
-        log.warn(`${errMessage} and no proxy`)
-        throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
-      }
-      step = 'addDfspIdToProxyMapping-1'
-      const isCached = await proxyCache.addDfspIdToProxyMapping(source, proxy)
-      // think,if we should throw error if isCached === false?
-      log.info('addDfspIdToProxyMapping is done', { source, proxy, isCached })
-    }
+    await service.validateSourceParticipant({ source, proxy })
 
-    if (proxyEnabled && proxy) {
-      const alsReq = partiesUtils.alsRequestDto(destination, params)
-      step = 'receivedSuccessResponse-2'
-      const isExists = await proxyCache.receivedSuccessResponse(alsReq)
-      if (!isExists) {
-        log.warn('destination is NOT in scheme, and no cached sendToProxiesList', { destination, alsReq })
-        // todo: think, if we need to throw an error here
-      } else {
-        const mappingPayload = {
-          fspId: source
-        }
-        step = 'oracleRequest-3'
-        await oracle.oracleRequest(headers, RestMethods.POST, params, null, mappingPayload, cache)
-        log.info('oracle was updated with mappingPayload', { mappingPayload })
-      }
-    }
-    step = 'validateParticipant-4'
-    const destinationParticipant = await participant.validateParticipant(destination)
-    if (!destinationParticipant) {
-      step = 'lookupProxyByDfspId-5'
-      const proxyName = proxyEnabled && await proxyCache.lookupProxyByDfspId(destination)
-      if (!proxyName) {
-        const errMessage = ERROR_MESSAGES.partyDestinationFspNotFound
-        log.warn(errMessage)
-        throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.DESTINATION_FSP_ERROR, errMessage)
-      }
-      sendTo = proxyName
-    } else {
-      sendTo = destinationParticipant.name
+    if (proxy) {
+      await service.checkProxySuccessResponse({ destination, source, headers, params })
     }
 
-    const decodedPayload = decodePayload(dataUri, { asParsed: false })
-    const callbackEndpointType = partiesUtils.putPartyCbType(params.SubId)
-    const options = partiesUtils.partiesRequestOptionsDto(params)
-    step = 'sendRequest-6'
-    await participant.sendRequest(headers, sendTo, callbackEndpointType, RestMethods.PUT, decodedPayload.body.toString(), options)
+    const sendTo = await service.identifyDestinationForSuccessCallback(destination)
+    results.requester = sendTo
+    await service.sendSuccessCallback({ sendTo, headers, params, dataUri })
 
-    log.info('parties::putPartiesByTypeAndID::callback was sent', { sendTo })
+    log.info('putPartiesByTypeAndID callback was sent', { sendTo })
     histTimerEnd({ success: true })
-  } catch (err) {
-    const fspiopError = await partiesUtils.createErrorHandlerOnSendingCallback(Config, log)(err, headers, params, sendTo)
-    if (fspiopError) {
-      libUtil.countFspiopError(fspiopError, { operation: components, step })
+  } catch (error) {
+    const { requester } = results
+    results.fspiopError = await service.handleError({ error, requester, headers, params })
+    if (results.fspiopError) {
+      libUtil.countFspiopError(results.fspiopError, { operation: component, step: stepState.step })
     }
     histTimerEnd({ success: false })
   }
@@ -158,101 +116,55 @@ const putPartiesErrorByTypeAndID = async (headers, params, payload, dataUri, spa
     'Put parties error by type and id',
     ['success']
   ).startTimer()
-  const log = logger.child({ params, component })
+  const childSpan = span ? span.getChild(component) : undefined
+  const log = logger.child({ component, params })
+  const stepState = libUtil.initStepState()
+
+  const deps = createDeps({ cache, proxyCache, childSpan, log, stepState })
+  const service = new services.PutPartiesErrorService(deps)
+  const results = {}
+
   const destination = headers[Headers.FSPIOP.DESTINATION]
   const proxyEnabled = !!(Config.PROXY_CACHE_CONFIG.enabled && proxyCache)
   const proxy = proxyEnabled && headers[Headers.FSPIOP.PROXY]
-
-  const childSpan = span ? span.getChild(component) : undefined
-  const stepState = libUtil.initStepState()
   log.info('parties::putPartiesErrorByTypeAndID start', { destination, proxy })
 
-  let sendTo
-  let fspiopError
-
   try {
     if (proxy) {
-      const isDone = await processProxyErrorCallback({
-        headers, params, payload, childSpan, cache, proxyCache, log, proxy, destination, stepState
-      })
-      if (isDone) {
+      const notValid = await service.checkPayee({ headers, params, payload, proxy })
+      if (notValid) {
+        const getPartiesService = new services.GetPartiesService(deps)
+        // todo: think, if we need to remove destination header before starting new discovery
+        await getPartiesService.handleRequest({ headers, params, results })
+        log.info('putPartiesErrorByTypeAndID triggered new discovery flow')
+        histTimerEnd({ success: true })
+        return
+      }
+
+      const isLast = await service.checkLastProxyCallback({ destination, proxy, params })
+      if (!isLast) {
         log.info('putPartiesErrorByTypeAndID proxy callback was processed', { proxy })
         histTimerEnd({ success: true })
         return
       }
     }
 
-    sendTo = await identifyDestinationForErrorCallback({
-      destination, proxyCache, proxyEnabled, log, stepState
-    })
-
-    await sendErrorCallbackToParticipant({
-      sendTo, headers, params, dataUri, childSpan, stepState
-    })
+    const sendTo = await service.identifyDestinationForErrorCallback(destination)
+    results.requester = sendTo
+    await service.sendErrorCallbackToParticipant({ sendTo, headers, params, dataUri })
 
     log.info('putPartiesErrorByTypeAndID callback was sent', { sendTo })
     histTimerEnd({ success: true })
-  } catch (err) {
-    fspiopError = await partiesUtils.createErrorHandlerOnSendingCallback(Config, log)(err, headers, params, sendTo)
-    if (fspiopError) {
-      libUtil.countFspiopError(fspiopError, { operation: component, step: stepState.step })
+  } catch (error) {
+    const { requester } = results
+    results.fspiopError = await service.handleError({ error, requester, headers, params })
+    if (results.fspiopError) {
+      libUtil.countFspiopError(results.fspiopError, { operation: component, step: stepState.step })
     }
     histTimerEnd({ success: false })
   } finally {
-    await libUtil.finishSpanWithError(childSpan, fspiopError)
-  }
-}
-
-const processProxyErrorCallback = async ({
-  headers, params, payload, childSpan, cache, proxyCache, log, proxy, destination, stepState
-}) => {
-  log.verbose('processProxyErrorCallback...')
-  let isDone // whether or not to continue putPartiesErrorByTypeAndID
-
-  if (isNotValidPayeeCase(payload)) {
-    stepState.inProgress('notValidPayeeCase-1')
-    log.info('notValidPayee case - deleted Participants and run getPartiesByTypeAndID', { proxy, payload })
-    const swappedHeaders = partiesUtils.swapSourceDestinationHeaders(headers)
-    await oracle.oracleRequest(swappedHeaders, RestMethods.DELETE, params, null, null, cache)
-    getPartiesByTypeAndID(swappedHeaders, params, RestMethods.GET, {}, childSpan, cache, proxyCache)
-    isDone = true
-  } else {
-    stepState.inProgress('receivedErrorResponse-2')
-    const alsReq = partiesUtils.alsRequestDto(destination, params) // or source?
-    const isLast = await proxyCache.receivedErrorResponse(alsReq, proxy)
-    log.info(`got${isLast ? '' : 'NOT'} last error callback from proxy`, { proxy, alsReq, isLast })
-    isDone = !isLast
+    await libUtil.finishSpanWithError(childSpan, results.fspiopError)
   }
-  return isDone
-}
-
-const identifyDestinationForErrorCallback = async ({
-  destination, proxyCache, proxyEnabled, log, stepState
-}) => {
-  stepState.inProgress('validateParticipant-3')
-  const destinationParticipant = await participant.validateParticipant(destination)
-  if (destinationParticipant) return destination
-
-  stepState.inProgress('lookupProxyDestination-4')
-  const proxyName = proxyEnabled && await proxyCache.lookupProxyByDfspId(destination)
-  if (proxyName) return proxyName
-
-  const errMessage = ERROR_MESSAGES.partyDestinationFspNotFound
-  log.warn(errMessage)
-  throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.DESTINATION_FSP_ERROR, errMessage)
-}
-
-const sendErrorCallbackToParticipant = async ({
-  sendTo, headers, params, dataUri, childSpan, stepState
-}) => {
-  stepState.inProgress('sendErrorToParticipant-5')
-  const decodedPayload = decodePayload(dataUri, { asParsed: false })
-  const callbackEndpointType = partiesUtils.errorPartyCbType(params.SubId)
-  await participant.sendErrorToParticipant(sendTo, callbackEndpointType, decodedPayload.body.toString(), headers, params, childSpan)
-}
-
-function isNotValidPayeeCase (payload) {
-  return payload?.errorInformation?.errorCode === MojaloopApiErrorCodes.PAYEE_IDENTIFIER_NOT_VALID.code
 }
 
 module.exports = {

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

@@ -0,0 +1,94 @@
+/*****
+ 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 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
+ * Eugen Klymniuk <eugen.klymniuk@infitx.com>
+
+ --------------
+ ******/
+
+const ErrorHandler = require('@mojaloop/central-services-error-handling')
+const { decodePayload } = require('@mojaloop/central-services-shared').Util.StreamingProtocol
+const { Enum } = require('@mojaloop/central-services-shared')
+
+const { FspEndpointTypes, FspEndpointTemplates } = Enum.EndPoints
+const { Headers, RestMethods } = Enum.Http
+
+class BasePartiesService {
+  constructor (deps) {
+    this.deps = deps
+    this.log = this.deps.log.child({ component: this.constructor.name })
+    this.proxyEnabled = !!(deps.config.PROXY_CACHE_CONFIG?.enabled && deps.proxyCache)
+  }
+
+  async handleRequest () {
+    throw new Error('handleRequest must be implemented by subclass')
+  }
+
+  async handleError ({ error, requester, headers, params }) {
+    const log = this.log.child({ method: 'handleError' })
+    try {
+      log.error('error in processing parties request: ', error)
+      const sendTo = requester || headers[Headers.FSPIOP.SOURCE]
+      const fspiopError = ErrorHandler.Factory.reformatFSPIOPError(error)
+      const errorInfo = await this.deps.partiesUtils.makePutPartiesErrorPayload(this.deps.config, fspiopError, headers, params)
+
+      await this.sendErrorCallback({ sendTo, errorInfo, headers, params })
+      log.info('handleError in done', { sendTo, errorInfo })
+      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.
+      log.error('failed to handleError. No further processing! ', exc)
+    }
+  }
+
+  async validateParticipant (participantId) {
+    return this.deps.participant.validateParticipant(participantId)
+  }
+
+  async sendErrorCallback ({ sendTo, errorInfo, headers, params, payload = undefined }) {
+    const endpointType = this.deps.partiesUtils.errorPartyCbType(params.SubId)
+    return this.deps.participant.sendErrorToParticipant(
+      sendTo, endpointType, errorInfo, headers, params, payload, this.deps.childSpan
+    )
+  }
+
+  async sendDeleteOracleRequest (headers, params) {
+    return this.deps.oracle.oracleRequest(headers, RestMethods.DELETE, params, null, null, this.deps.cache)
+  }
+
+  static decodeDataUriPayload (dataUri) {
+    const decoded = decodePayload(dataUri, { asParsed: false })
+    return decoded.body.toString()
+  }
+
+  static enums () {
+    return {
+      FspEndpointTypes,
+      FspEndpointTemplates,
+      Headers,
+      RestMethods
+    }
+  }
+}
+
+module.exports = BasePartiesService

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

@@ -26,24 +26,18 @@
  ******/
 
 const ErrorHandler = require('@mojaloop/central-services-error-handling')
-const { Enum } = require('@mojaloop/central-services-shared')
 const { ERROR_MESSAGES } = require('../../../constants')
 const { createCallbackHeaders } = require('../../../lib/headers')
+const BasePartiesService = require('./BasePartiesService')
 
-const { FspEndpointTypes, FspEndpointTemplates } = Enum.EndPoints
-const { Headers, RestMethods } = Enum.Http
+const {
+  FspEndpointTypes, FspEndpointTemplates,
+  Headers, RestMethods
+} = BasePartiesService.enums()
 
 const proxyCacheTtlSec = 40 // todo: make configurable
 
-class GetPartiesService {
-  #deps
-
-  constructor (deps) {
-    this.#deps = deps
-    this.log = this.#deps.log.child({ component: this.constructor.name })
-    this.proxyEnabled = !!(deps.config.PROXY_CACHE_CONFIG?.enabled && deps.proxyCache)
-  }
-
+class GetPartiesService extends BasePartiesService {
   async handleRequest ({ headers, params, query, results }) {
     const source = headers[Headers.FSPIOP.SOURCE]
     const proxy = headers[Headers.FSPIOP.PROXY]
@@ -72,17 +66,18 @@ class GetPartiesService {
     const proxyNames = await this.getFilteredProxyList(proxy)
 
     if (proxyNames.length) {
-      return this.triggerSendToProxiesFlow({ proxyNames, headers, params, source })
+      await this.triggerSendToProxiesFlow({ proxyNames, headers, params, source })
+      return
     }
 
-    results.fspiopError = await this.sendErrorCallback({ requester, headers, params })
+    results.fspiopError = await this.sendPartyNotFoundErrorCallback({ requester, headers, params })
   }
 
   async validateRequester ({ source, proxy }) {
-    this.#deps.stepState.inProgress('validateRequester-0')
+    this.deps.stepState.inProgress('validateRequester-0')
     const log = this.log.child({ source, method: 'validateRequester' })
 
-    const sourceParticipant = await this.#validateParticipant(source)
+    const sourceParticipant = await this.validateParticipant(source)
     if (sourceParticipant) {
       log.debug('source is in scheme')
       return source
@@ -94,28 +89,28 @@ class GetPartiesService {
       throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
     }
 
-    const proxyParticipant = await this.#validateParticipant(proxy)
+    const proxyParticipant = await this.validateParticipant(proxy)
     if (!proxyParticipant) {
       const errMessage = ERROR_MESSAGES.partyProxyNotFound
       log.warn(errMessage, { proxy })
       throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
     }
 
-    const isCached = await this.#deps.proxyCache.addDfspIdToProxyMapping(source, proxy)
+    const isCached = await this.deps.proxyCache.addDfspIdToProxyMapping(source, proxy)
     // think, what if isCached !== true?
     log.info('source is added to proxyMapping cache:', { proxy, isCached })
     return proxy
   }
 
   async forwardRequestToDestination ({ destination, headers, params }) {
-    this.#deps.stepState.inProgress('validateDestination-1')
+    this.deps.stepState.inProgress('validateDestination-1')
     const log = this.log.child({ method: 'forwardRequestToDestination' })
     let sendTo = destination
 
-    const destParticipantModel = await this.#validateParticipant(destination)
+    const destParticipantModel = await this.validateParticipant(destination)
     if (!destParticipantModel) {
-      this.#deps.stepState.inProgress('lookupProxyDestination-2')
-      const proxyId = this.proxyEnabled && await this.#deps.proxyCache.lookupProxyByDfspId(destination)
+      this.deps.stepState.inProgress('lookupProxyDestination-2')
+      const proxyId = this.proxyEnabled && await this.deps.proxyCache.lookupProxyByDfspId(destination)
 
       if (!proxyId) {
         log.warn('no destination participant, and no dfsp-to-proxy mapping', { destination })
@@ -131,8 +126,8 @@ class GetPartiesService {
 
   filterOraclePartyList ({ response, params }) {
     // 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.#deps.stepState.inProgress('filterOraclePartyList-5')
-    const callbackEndpointType = this.#deps.partiesUtils.getPartyCbType(params.SubId)
+    this.deps.stepState.inProgress('filterOraclePartyList-5')
+    const callbackEndpointType = this.deps.partiesUtils.getPartyCbType(params.SubId)
     let filteredResponsePartyList
 
     switch (callbackEndpointType) {
@@ -148,7 +143,7 @@ class GetPartiesService {
 
     if (!Array.isArray(filteredResponsePartyList) || !filteredResponsePartyList.length) {
       const errMessage = 'Requested FSP/Party not found'
-      this.#deps.log.warn(errMessage)
+      this.log.warn(errMessage)
       throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
     }
 
@@ -165,8 +160,8 @@ class GetPartiesService {
       if (!destination) {
         clonedHeaders[Headers.FSPIOP.DESTINATION] = fspId
       }
-      this.#deps.stepState.inProgress('validateParticipant-6')
-      const schemeParticipant = await this.#validateParticipant(fspId)
+      this.deps.stepState.inProgress('validateParticipant-6')
+      const schemeParticipant = await this.validateParticipant(fspId)
       if (schemeParticipant) {
         sentCount++
         log.info('participant is in scheme', { fspId })
@@ -180,8 +175,8 @@ class GetPartiesService {
       // If the participant is not in the scheme and proxy routing is enabled,
       // we should check if there is a proxy for it and send the request to the proxy
       if (this.proxyEnabled) {
-        this.#deps.stepState.inProgress('lookupProxyByDfspId-7')
-        const proxyName = await this.#deps.proxyCache.lookupProxyByDfspId(fspId)
+        this.deps.stepState.inProgress('lookupProxyByDfspId-7')
+        const proxyName = await this.deps.proxyCache.lookupProxyByDfspId(fspId)
         if (!proxyName) {
           log.warn('no proxyMapping for participant!  TODO: Delete reference in oracle...', { fspId })
           // todo: delete reference in oracle
@@ -202,30 +197,30 @@ class GetPartiesService {
   }
 
   async getFilteredProxyList (proxy) {
-    this.#deps.stepState.inProgress('getAllProxies-8')
+    this.deps.stepState.inProgress('getAllProxies-8')
     if (!this.proxyEnabled) {
       this.log.warn('proxyCache is not enabled')
       return []
     }
 
-    const proxyNames = await this.#deps.proxies.getAllProxiesNames(this.#deps.config.SWITCH_ENDPOINT)
+    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 triggerSendToProxiesFlow ({ proxyNames, headers, params, source }) {
     const log = this.log.child({ method: 'triggerSendToProxiesFlow' })
-    this.#deps.stepState.inProgress('setSendToProxiesList-10')
-    const alsReq = this.#deps.partiesUtils.alsRequestDto(source, params)
+    this.deps.stepState.inProgress('setSendToProxiesList-10')
+    const alsReq = this.deps.partiesUtils.alsRequestDto(source, params)
     log.info('starting setSendToProxiesList flow: ', { proxyNames, alsReq, proxyCacheTtlSec })
 
-    const isCached = await this.#deps.proxyCache.setSendToProxiesList(alsReq, proxyNames, proxyCacheTtlSec)
+    const isCached = await this.deps.proxyCache.setSendToProxiesList(alsReq, proxyNames, proxyCacheTtlSec)
     if (!isCached) {
       log.warn('failed to setSendToProxiesList')
       throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, ERROR_MESSAGES.failedToCacheSendToProxiesList)
     }
 
-    this.#deps.stepState.inProgress('sendingProxyRequests-11')
+    this.deps.stepState.inProgress('sendingProxyRequests-11')
     const sending = proxyNames.map(
       sendTo => this.#forwardGetPartiesRequest({ sendTo, headers, params })
         .then(({ status, data } = {}) => ({ status, data }))
@@ -236,31 +231,15 @@ class GetPartiesService {
     // Failed requests should be handled by TTL expired/timeout handler
     // todo: - think, if we should handle failed requests here (e.g., by calling receivedErrorResponse)
     log.info('triggerSendToProxiesFlow is done:', { isOk, results, proxyNames, alsReq })
-    this.#deps.stepState.inProgress('allSent-12')
+    this.deps.stepState.inProgress('allSent-12')
     if (!isOk) {
       log.warn('no successful requests sent to proxies')
       throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, ERROR_MESSAGES.proxyConnectionError)
     }
   }
 
-  async #validateParticipant (participantId) {
-    return this.#deps.participant.validateParticipant(participantId)
-  }
-
-  async #forwardGetPartiesRequest ({ sendTo, headers, params }) {
-    this.#deps.stepState.inProgress('forwardRequest-3')
-    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)
-  }
-
-  // async sendSuccessCallback ({ headers, sendTo }) {
-  //   return this.#deps.participant.sendRequest(headers, sendTo,)
-  // }
-
-  async sendErrorCallback ({ requester, headers, params }) {
-    this.#deps.stepState.inProgress('sendErrorCallback-9')
+  async sendPartyNotFoundErrorCallback ({ requester, headers, params }) {
+    this.deps.stepState.inProgress('sendErrorCallback-9')
     const callbackHeaders = createCallbackHeaders({
       requestHeaders: headers,
       partyIdType: params.Type,
@@ -271,20 +250,26 @@ class GetPartiesService {
     })
     const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.PARTY_NOT_FOUND)
 
-    await this.#deps.participant.sendErrorToParticipant(
-      requester,
-      this.#deps.partiesUtils.errorPartyCbType(params.SubId),
-      fspiopError.toApiErrorObject(this.#deps.config.ERROR_HANDLING),
-      callbackHeaders,
-      params,
-      this.#deps.childSpan
-    )
+    await this.sendErrorCallback({
+      sendTo: requester,
+      errorInfo: fspiopError.toApiErrorObject(this.deps.config.ERROR_HANDLING),
+      headers: callbackHeaders,
+      params
+    })
     return fspiopError
   }
 
   async sendOracleDiscoveryRequest ({ headers, params, query }) {
-    this.#deps.stepState.inProgress('oracleRequest-4')
-    return this.#deps.oracle.oracleRequest(headers, RestMethods.GET, params, query, undefined, this.#deps.cache)
+    this.deps.stepState.inProgress('oracleRequest-4')
+    return this.deps.oracle.oracleRequest(headers, RestMethods.GET, params, query, undefined, this.deps.cache)
+  }
+
+  async #forwardGetPartiesRequest ({ sendTo, headers, params }) {
+    this.deps.stepState.inProgress('forwardRequest-3')
+    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)
   }
 }
 

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

@@ -0,0 +1,80 @@
+/*****
+ 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 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
+ * Eugen Klymniuk <eugen.klymniuk@infitx.com>
+
+ --------------
+ ******/
+
+const ErrorHandler = require('@mojaloop/central-services-error-handling')
+const { ERROR_MESSAGES } = require('../../../constants')
+const BasePartiesService = require('./BasePartiesService')
+
+class PutPartiesErrorService extends BasePartiesService {
+  async handleRequest () {
+    // todo: add impl.
+  }
+
+  async checkPayee ({ headers, params, payload, proxy }) {
+    const notValid = this.deps.partiesUtils.isNotValidPayeeCase(payload)
+    if (notValid) {
+      this.deps.stepState.inProgress('notValidPayeeCase-1')
+      this.log.warn('notValidPayee case - deleting Participants and run getPartiesByTypeAndID', { proxy, payload })
+      const swappedHeaders = this.deps.partiesUtils.swapSourceDestinationHeaders(headers)
+      await super.sendDeleteOracleRequest(swappedHeaders, params)
+    }
+    return notValid
+  }
+
+  async checkLastProxyCallback ({ destination, proxy, params }) {
+    this.deps.stepState.inProgress('checkLastProxyCallback-2')
+    const alsReq = this.deps.partiesUtils.alsRequestDto(destination, params) // or source?
+    const isLast = await this.deps.proxyCache.receivedErrorResponse(alsReq, proxy)
+    this.log.info(`got${isLast ? '' : 'NOT'} last error callback from proxy`, { proxy, alsReq, isLast })
+    return isLast
+  }
+
+  async identifyDestinationForErrorCallback (destination) {
+    this.deps.stepState.inProgress('validateParticipant-3')
+    const destinationParticipant = await super.validateParticipant(destination)
+    if (destinationParticipant) return destination
+
+    this.deps.stepState.inProgress('lookupProxyDestination-4')
+    const proxyName = this.proxyEnabled && await this.deps.proxyCache.lookupProxyByDfspId(destination)
+    if (proxyName) return proxyName
+
+    const errMessage = ERROR_MESSAGES.partyDestinationFspNotFound
+    this.log.warn(errMessage, { destination })
+    throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.DESTINATION_FSP_ERROR, errMessage)
+  }
+
+  async sendErrorCallbackToParticipant ({ sendTo, headers, params, dataUri }) {
+    this.deps.stepState.inProgress('sendErrorToParticipant-5')
+    const errorInfo = PutPartiesErrorService.decodeDataUriPayload(dataUri)
+    await super.sendErrorCallback({
+      sendTo, errorInfo, headers, params
+    })
+    this.log.verbose('sendErrorCallbackToParticipant is done', { sendTo, errorInfo })
+  }
+}
+
+module.exports = PutPartiesErrorService

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

@@ -0,0 +1,108 @@
+/*****
+ 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 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
+ * Eugen Klymniuk <eugen.klymniuk@infitx.com>
+
+ --------------
+ ******/
+
+const ErrorHandler = require('@mojaloop/central-services-error-handling')
+const { ERROR_MESSAGES } = require('../../../constants')
+const BasePartiesService = require('./BasePartiesService')
+
+const { RestMethods } = BasePartiesService.enums()
+
+class PutPartiesService extends BasePartiesService {
+  async handleRequest () {
+    // todo: add impl.
+  }
+
+  async validateSourceParticipant ({ source, proxy }) {
+    this.deps.stepState.inProgress('validateSourceParticipant-1')
+    const requesterParticipant = await super.validateParticipant(source)
+
+    if (!requesterParticipant) {
+      if (!this.proxyEnabled || !proxy) {
+        const errMessage = ERROR_MESSAGES.sourceFspNotFound
+        this.log.warn(`${errMessage} and no proxy`, { source })
+        throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
+      }
+      const isCached = await this.deps.proxyCache.addDfspIdToProxyMapping(source, proxy)
+      // todo: think,if we should throw error if isCached === false?
+      this.log.info('addDfspIdToProxyMapping is done', { source, proxy, isCached })
+    }
+  }
+
+  async checkProxySuccessResponse ({ destination, source, headers, params }) {
+    if (this.proxyEnabled) {
+      this.deps.stepState.inProgress('checkProxySuccessResponse-2')
+      const alsReq = this.deps.partiesUtils.alsRequestDto(destination, params)
+
+      const isExists = await this.deps.proxyCache.receivedSuccessResponse(alsReq)
+      if (isExists) {
+        await this.#updateOracleWithParticipantMapping({ source, headers, params })
+        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
+    }
+  }
+
+  async identifyDestinationForSuccessCallback (destination) {
+    this.deps.stepState.inProgress('validateDestinationParticipant-4')
+    const destinationParticipant = await super.validateParticipant(destination)
+    if (destinationParticipant) {
+      return destinationParticipant.name
+    }
+
+    const proxyName = this.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)
+    }
+    return proxyName
+  }
+
+  async sendSuccessCallback ({ sendTo, headers, params, dataUri }) {
+    this.deps.stepState.inProgress('#sendSuccessCallback-6')
+    const payload = PutPartiesService.decodeDataUriPayload(dataUri)
+    const callbackEndpointType = this.deps.partiesUtils.putPartyCbType(params.SubId)
+    const options = this.deps.partiesUtils.partiesRequestOptionsDto(params)
+
+    await this.deps.participant.sendRequest(
+      headers, sendTo, callbackEndpointType, RestMethods.PUT, payload, options
+    )
+    this.log.verbose('sendSuccessCallback is done', { sendTo, payload })
+  }
+
+  async #updateOracleWithParticipantMapping ({ source, headers, params }) {
+    this.deps.stepState.inProgress('#updateOracleWithParticipantMapping-3')
+    const mappingPayload = {
+      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 })
+  }
+}
+
+module.exports = PutPartiesService

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

@@ -26,7 +26,11 @@
  ******/
 
 const GetPartiesService = require('./GetPartiesService')
+const PutPartiesService = require('./PutPartiesService')
+const PutPartiesErrorService = require('./PutPartiesErrorService')
 
 module.exports = {
-  GetPartiesService
+  GetPartiesService,
+  PutPartiesService,
+  PutPartiesErrorService
 }