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

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

@@ -25,185 +25,170 @@
  --------------
  ******/
 
-const ErrorHandler = require('@mojaloop/central-services-error-handling')
 const { ERROR_MESSAGES } = require('../../../constants')
-const { createCallbackHeaders } = require('../../../lib/headers')
 const BasePartiesService = require('./BasePartiesService')
 
-const {
-  FspEndpointTypes, FspEndpointTemplates,
-  Headers, RestMethods
-} = BasePartiesService.enums()
-
+const { FspEndpointTypes, RestMethods } = BasePartiesService.enums()
 const proxyCacheTtlSec = 40 // todo: make configurable
 
 class GetPartiesService extends BasePartiesService {
-  async handleRequest ({ headers, params, query, results }) {
-    const source = headers[Headers.FSPIOP.SOURCE]
-    const proxy = headers[Headers.FSPIOP.PROXY]
-    const destination = headers[Headers.FSPIOP.DESTINATION]
+  async handleRequest () {
+    const { destination, source, proxy } = this.state
     // see https://github.com/mojaloop/design-authority/issues/79
     // the requester has specified a destination routing header. We should respect that and forward the request directly to the destination
     // without consulting any oracles.
-    this.log.info('handling getParties request', { source, destination, proxy })
-
-    const requester = await this.validateRequester({ source, proxy })
-    results.requester = requester
+    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({ destination, headers, params })
+      await this.forwardRequestToDestination()
       return
     }
-    const response = await this.sendOracleDiscoveryRequest({ headers, params, query })
 
+    const response = await this.sendOracleDiscoveryRequest()
     if (Array.isArray(response?.data?.partyList) && response.data.partyList.length > 0) {
-      const partyList = this.filterOraclePartyList({ response, params })
-      await this.processOraclePartyList({ partyList, headers, params, destination })
+      const partyList = this.filterOraclePartyList(response)
+      await this.processOraclePartyList(partyList)
       return
     }
 
-    this.log.info('empty partyList form oracle, getting proxyList...', { params })
-    const proxyNames = await this.getFilteredProxyList(proxy)
-
-    if (proxyNames.length) {
-      await this.triggerSendToProxiesFlow({ proxyNames, headers, params, source })
-      return
+    this.log.info('empty partyList form oracle, checking inter-scheme discovery flow...')
+    const fspiopError = await this.triggerInterSchemeDiscoveryFlow(this.inputs.headers)
+    if (fspiopError) {
+      this.state.fspiopError = fspiopError // todo: think, if we need this
     }
-
-    results.fspiopError = await this.sendPartyNotFoundErrorCallback({ requester, headers, params })
   }
 
-  async validateRequester ({ source, proxy }) {
-    this.deps.stepState.inProgress('validateRequester-0')
+  async validateRequester () {
+    const { source, proxy, proxyEnabled } = this.state
     const log = this.log.child({ source, proxy, method: 'validateRequester' })
+    this.stepInProgress('validateRequester-0')
 
-    const sourceParticipant = await this.validateParticipant(source)
-    if (sourceParticipant) {
-      log.debug('source is in scheme')
+    const schemeSource = await this.validateParticipant(source)
+    if (schemeSource) {
+      log.debug('source participant is in scheme')
       return source
     }
 
-    if (!this.proxyEnabled || !proxy) {
-      const errMessage = ERROR_MESSAGES.sourceFspNotFound
-      log.warn(errMessage)
-      throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
+    if (!proxyEnabled || !proxy) {
+      throw super.createFspiopIdNotFoundError(ERROR_MESSAGES.sourceFspNotFound, log)
     }
 
-    const proxyParticipant = await this.validateParticipant(proxy)
-    if (!proxyParticipant) {
-      const errMessage = ERROR_MESSAGES.partyProxyNotFound
-      log.warn(errMessage)
-      throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
+    const schemeProxy = await this.validateParticipant(proxy)
+    if (!schemeProxy) {
+      throw super.createFspiopIdNotFoundError(ERROR_MESSAGES.partyProxyNotFound, log)
     }
 
     const isCached = await this.deps.proxyCache.addDfspIdToProxyMapping(source, proxy)
     if (!isCached) {
-      const errMessage = 'failed to addDfspIdToProxyMapping'
-      log.warn(errMessage)
-      throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
+      throw super.createFspiopIdNotFoundError('failed to addDfspIdToProxyMapping', log)
     }
 
     log.info('source is added to proxyMapping cache:', { proxy, isCached })
     return proxy
   }
 
-  async forwardRequestToDestination ({ destination, headers, params }) {
-    this.deps.stepState.inProgress('validateDestination-1')
+  async forwardRequestToDestination () {
+    const { headers, params } = this.inputs
+    const { destination } = this.state
     const log = this.log.child({ method: 'forwardRequestToDestination' })
     let sendTo = 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)
+    const schemeParticipant = await this.validateParticipant(destination)
+    if (!schemeParticipant) {
+      this.stepInProgress('lookupProxyDestination-2')
+      const proxyId = this.state.proxyEnabled && await this.deps.proxyCache.lookupProxyByDfspId(destination)
 
       if (!proxyId) {
-        log.warn('no destination participant, and no dfsp-to-proxy mapping', { destination })
-        const errMessage = ERROR_MESSAGES.partyDestinationFspNotFound
-        throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
+        log.warn('destination participant is not in scheme, and no dfsp-to-proxy mapping', { destination })
+        await super.sendDeleteOracleRequest(headers, params)
+        await this.triggerInterSchemeDiscoveryFlow(GetPartiesService.headersWithoutDestination(headers))
+        return
       }
       sendTo = proxyId
     }
-    // all ok, go ahead and forward the request
+
     await this.#forwardGetPartiesRequest({ sendTo, headers, params })
     log.info('discovery getPartiesByTypeAndID request was sent', { sendTo })
   }
 
-  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')
+  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 filteredResponsePartyList
+    let filteredPartyList
 
     switch (callbackEndpointType) {
       case FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTIES_GET:
-        filteredResponsePartyList = response.data.partyList.filter(party => party.partySubIdOrType == null) // Filter records that DON'T contain a partySubIdOrType
+        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:
-        filteredResponsePartyList = response.data.partyList.filter(party => party.partySubIdOrType === params.SubId) // Filter records that match partySubIdOrType
+        filteredPartyList = response.data.partyList.filter(party => party.partySubIdOrType === params.SubId) // Filter records that match partySubIdOrType
         break
       default:
-        filteredResponsePartyList = response // Fallback to providing the standard list
+        filteredPartyList = response // Fallback to providing the standard list
     }
 
-    if (!Array.isArray(filteredResponsePartyList) || !filteredResponsePartyList.length) {
-      const errMessage = 'Requested FSP/Party not found'
-      this.log.warn(errMessage)
-      throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
+    if (!Array.isArray(filteredPartyList) || !filteredPartyList.length) {
+      throw super.createFspiopIdNotFoundError(ERROR_MESSAGES.emptyFilteredPartyList)
     }
 
-    return filteredResponsePartyList
+    return filteredPartyList
   }
 
-  async processOraclePartyList ({ partyList, headers, params, destination }) {
-    const log = this.log.child({ method: 'processOraclePartyList' })
+  async processOraclePartyList (partyList) {
+    this.stepInProgress('processOraclePartyList')
+    const { headers, params } = this.inputs
 
-    let sentCount = 0 // if sentCount === 0 after sending, should we restart the whole process?
+    let sentCount = 0 // if sentCount === 0 after sending, we send idNotFound error
     const sending = partyList.map(async party => {
       const { fspId } = party
-      const clonedHeaders = { ...headers }
-      if (!destination) {
-        clonedHeaders[Headers.FSPIOP.DESTINATION] = fspId
-      }
-      this.deps.stepState.inProgress('validateParticipant-6')
+
       const schemeParticipant = await this.validateParticipant(fspId)
       if (schemeParticipant) {
         sentCount++
-        log.info('participant is in scheme', { fspId })
+        this.log.info('participant is in scheme, so forwarding to it...', { fspId })
         return this.#forwardGetPartiesRequest({
           sendTo: fspId,
-          headers: clonedHeaders,
+          headers: GetPartiesService.overrideDestinationHeader(headers, fspId),
           params
         })
       }
 
-      // 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')
+      if (this.state.proxyEnabled) {
         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
-        } else {
+          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++
-          log.info('participant is NOT in scheme, use proxy name', { fspId, proxyName })
+          this.log.info('participant is NOT in scheme, but source is. So forwarding to proxy...', { fspId, proxyName })
           return this.#forwardGetPartiesRequest({
             sendTo: proxyName,
-            headers: clonedHeaders,
+            headers: GetPartiesService.overrideDestinationHeader(headers, fspId),
             params
           })
         }
       }
     })
     await Promise.all(sending)
-    log.verbose('processOraclePartyList is done', { sentCount })
-    // todo: think what if sentCount === 0 here
+    this.log.verbose('processOraclePartyList is done', { sentCount })
+
+    if (sentCount === 0) throw super.createFspiopIdNotFoundError(ERROR_MESSAGES.noDiscoveryRequestsForwarded)
   }
 
   async getFilteredProxyList (proxy) {
-    this.deps.stepState.inProgress('getAllProxies-8')
-    if (!this.proxyEnabled) {
+    this.stepInProgress('getFilteredProxyList')
+    if (!this.state.proxyEnabled) {
       this.log.warn('proxyCache is not enabled')
       return []
     }
@@ -213,19 +198,27 @@ class GetPartiesService extends BasePartiesService {
     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')
+  async triggerInterSchemeDiscoveryFlow (headers) {
+    const { params } = this.inputs
+    const { proxy, source } = this.state
+    const log = this.log.child({ method: 'triggerInterSchemeDiscoveryFlow' })
+    log.verbose('triggerInterSchemeDiscoveryFlow start...', { proxy, source })
+
+    const proxyNames = await this.getFilteredProxyList(proxy)
+    if (!proxyNames.length) {
+      return this.sendPartyNotFoundErrorCallback(headers)
+    }
+
+    this.stepInProgress('setSendToProxiesList-10')
     const alsReq = this.deps.partiesUtils.alsRequestDto(source, params)
-    log.info('starting setSendToProxiesList flow: ', { proxyNames, alsReq, proxyCacheTtlSec })
+    log.verbose('starting setSendToProxiesList flow: ', { proxyNames, alsReq, 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)
+      throw super.createFspiopIdNotFoundError(ERROR_MESSAGES.failedToCacheSendToProxiesList, log)
     }
 
-    this.deps.stepState.inProgress('sendingProxyRequests-11')
+    this.stepInProgress('sendingProxyRequests-11')
     const sending = proxyNames.map(
       sendTo => this.#forwardGetPartiesRequest({ sendTo, headers, params })
         .then(({ status, data } = {}) => ({ status, data }))
@@ -234,43 +227,34 @@ class GetPartiesService extends BasePartiesService {
     const isOk = results.some(result => result.status === 'fulfilled')
     // If, at least, one request is sent to proxy, we treat the whole flow as successful.
     // 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')
+    log.info('triggerInterSchemeDiscoveryFlow is done:', { isOk, results, proxyNames, alsReq })
+    this.stepInProgress('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)
+      throw super.createFspiopIdNotFoundError(ERROR_MESSAGES.proxyConnectionError, log)
     }
   }
 
-  async sendPartyNotFoundErrorCallback ({ requester, headers, params }) {
-    this.deps.stepState.inProgress('sendErrorCallback-9')
-    const callbackHeaders = createCallbackHeaders({
-      requestHeaders: headers,
-      partyIdType: params.Type,
-      partyIdentifier: params.ID,
-      endpointTemplate: params.SubId
-        ? FspEndpointTemplates.PARTIES_SUB_ID_PUT_ERROR
-        : FspEndpointTemplates.PARTIES_PUT_ERROR
-    })
-    const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.PARTY_NOT_FOUND)
+  async sendPartyNotFoundErrorCallback (headers) {
+    const { params } = this.inputs
+    const fspiopError = super.createFspiopIdNotFoundError('No proxy found to start inter-scheme discovery flow')
 
     await this.sendErrorCallback({
-      sendTo: requester,
       errorInfo: fspiopError.toApiErrorObject(this.deps.config.ERROR_HANDLING),
-      headers: callbackHeaders,
+      headers: GetPartiesService.createErrorCallbackHeaders(headers, params),
       params
     })
     return fspiopError
   }
 
-  async sendOracleDiscoveryRequest ({ headers, params, query }) {
-    this.deps.stepState.inProgress('oracleRequest-4')
+  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.deps.stepState.inProgress('forwardRequest-3')
+    this.stepInProgress('#forwardGetPartiesRequest')
     const callbackEndpointType = this.deps.partiesUtils.getPartyCbType(params.SubId)
     const options = this.deps.partiesUtils.partiesRequestOptionsDto(params)
 

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

@@ -30,49 +30,71 @@ 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)
+  async handleRequest () {
+    if (this.state.proxyEnabled && this.state.proxy) {
+      const alsReq = this.deps.partiesUtils.alsRequestDto(this.state.destination, this.inputs.params) // or source?
+      const isPending = await this.deps.proxyCache.isPendingCallback(alsReq)
+
+      if (!isPending) {
+        // not initial inter-scheme discovery case. Cleanup oracle and trigger inter-scheme discovery
+        this.log.warn('Need to cleanup oracle and trigger new inter-scheme discovery flow')
+        await this.cleanupOracle()
+        return true // need to trigger inter-scheme discovery
+      }
+
+      const isLast = await this.checkLastProxyCallback(alsReq)
+      if (!isLast) {
+        this.log.verbose('putPartiesErrorByTypeAndID proxy callback was processed')
+        return
+      }
     }
-    return notValid
+
+    await this.identifyDestinationForErrorCallback()
+    await this.sendErrorCallbackToParticipant()
+    this.log.info('putPartiesByTypeAndID is done')
   }
 
-  async checkLastProxyCallback ({ destination, proxy, params }) {
-    this.deps.stepState.inProgress('checkLastProxyCallback-2')
-    const alsReq = this.deps.partiesUtils.alsRequestDto(destination, params) // or source?
+  async cleanupOracle () {
+    this.stepInProgress('cleanupOracle')
+    const { headers, params, payload } = this.inputs
+    this.log.info('cleanupOracle due to error callback...', { payload })
+    const swappedHeaders = this.deps.partiesUtils.swapSourceDestinationHeaders(headers)
+    await super.sendDeleteOracleRequest(swappedHeaders, params)
+  }
+
+  async checkLastProxyCallback (alsReq) {
+    this.stepInProgress('checkLastProxyCallback')
+    const { proxy } = this.state
     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
+  async identifyDestinationForErrorCallback () {
+    this.stepInProgress('identifyDestinationForErrorCallback')
+    const { destination } = this.state
+    const schemeParticipant = await super.validateParticipant(destination)
+    if (schemeParticipant) {
+      this.state.requester = destination
+      return
+    }
 
-    this.deps.stepState.inProgress('lookupProxyDestination-4')
-    const proxyName = this.proxyEnabled && await this.deps.proxyCache.lookupProxyByDfspId(destination)
-    if (proxyName) return proxyName
+    this.stepInProgress('lookupProxyDestination-4')
+    const proxyName = this.state.proxyEnabled && await this.deps.proxyCache.lookupProxyByDfspId(destination)
+    if (proxyName) {
+      this.state.requester = proxyName
+      return
+    }
 
     const errMessage = ERROR_MESSAGES.partyDestinationFspNotFound
     this.log.warn(errMessage, { destination })
     throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.DESTINATION_FSP_ERROR, errMessage)
   }
 
-  async sendErrorCallbackToParticipant ({ sendTo, headers, params, dataUri }) {
-    this.deps.stepState.inProgress('sendErrorToParticipant-5')
+  async sendErrorCallbackToParticipant () {
+    const { headers, params, dataUri } = this.inputs
     const errorInfo = PutPartiesErrorService.decodeDataUriPayload(dataUri)
-    return super.sendErrorCallback({
-      sendTo, errorInfo, headers, params
-    })
+    return super.sendErrorCallback({ errorInfo, headers, params })
   }
 }
 

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

@@ -32,34 +32,43 @@ const BasePartiesService = require('./BasePartiesService')
 const { RestMethods } = BasePartiesService.enums()
 
 class PutPartiesService extends BasePartiesService {
-  // async handleRequest () {
-  //   // todo: add impl.
-  // }
+  async handleRequest () {
+    const { destination, source, proxy } = this.state
+    this.log.info('handleRequest start', { destination, source, proxy })
 
-  async validateSourceParticipant ({ source, proxy }) {
-    this.deps.stepState.inProgress('validateSourceParticipant-1')
-    const requesterParticipant = await super.validateParticipant(source)
+    await this.validateSourceParticipant()
+    if (proxy) {
+      await this.checkProxySuccessResponse()
+    }
+    await this.identifyDestinationForSuccessCallback()
+    await this.sendSuccessCallback()
+  }
+
+  async validateSourceParticipant () {
+    const { source, proxy, proxyEnabled } = this.state
+    const log = this.log.child({ source, proxy, method: 'validateSourceParticipant' })
+    this.stepInProgress('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)
+      if (!proxyEnabled || !proxy) {
+        throw super.createFspiopIdNotFoundError(ERROR_MESSAGES.sourceFspNotFound, log)
       }
+
       const isCached = await this.deps.proxyCache.addDfspIdToProxyMapping(source, proxy)
       if (!isCached) {
-        const errMessage = 'failed to addDfspIdToProxyMapping'
-        this.log.warn(errMessage, { source, proxy })
-        throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
+        throw super.createFspiopIdNotFoundError('failed to addDfspIdToProxyMapping', log)
       }
 
-      this.log.info('addDfspIdToProxyMapping is done', { source, proxy })
+      log.info('addDfspIdToProxyMapping is done', { source, proxy })
     }
   }
 
-  async checkProxySuccessResponse ({ destination, source, headers, params }) {
-    if (this.proxyEnabled) {
-      this.deps.stepState.inProgress('checkProxySuccessResponse-2')
+  async checkProxySuccessResponse () {
+    if (this.state.proxyEnabled) {
+      this.stepInProgress('checkProxySuccessResponse')
+      const { headers, params } = this.inputs
+      const { destination, source } = this.state
       const alsReq = this.deps.partiesUtils.alsRequestDto(destination, params)
 
       const isExists = await this.deps.proxyCache.receivedSuccessResponse(alsReq)
@@ -72,24 +81,29 @@ class PutPartiesService extends BasePartiesService {
     }
   }
 
-  async identifyDestinationForSuccessCallback (destination) {
-    this.deps.stepState.inProgress('validateDestinationParticipant-4')
+  async identifyDestinationForSuccessCallback () {
+    const { destination } = this.state
+    this.stepInProgress('identifyDestinationForSuccessCallback')
     const destinationParticipant = await super.validateParticipant(destination)
     if (destinationParticipant) {
-      return destinationParticipant.name
+      this.state.requester = destinationParticipant.name
+      return
     }
 
-    const proxyName = this.proxyEnabled && await this.deps.proxyCache.lookupProxyByDfspId(destination)
+    const proxyName = this.state.proxyEnabled && await this.deps.proxyCache.lookupProxyByDfspId(destination)
     if (!proxyName) {
       const errMessage = ERROR_MESSAGES.partyDestinationFspNotFound
       this.log.warn(`${errMessage} and no proxy`, { destination })
       throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.DESTINATION_FSP_ERROR, errMessage)
     }
-    return proxyName
+
+    this.state.requester = proxyName
   }
 
-  async sendSuccessCallback ({ sendTo, headers, params, dataUri }) {
-    this.deps.stepState.inProgress('#sendSuccessCallback-6')
+  async sendSuccessCallback () {
+    const { headers, params, dataUri } = this.inputs
+    const sendTo = this.state.requester
+    this.stepInProgress('sendSuccessCallback')
     const payload = PutPartiesService.decodeDataUriPayload(dataUri)
     const callbackEndpointType = this.deps.partiesUtils.putPartyCbType(params.SubId)
     const options = this.deps.partiesUtils.partiesRequestOptionsDto(params)
@@ -97,11 +111,11 @@ class PutPartiesService extends BasePartiesService {
     await this.deps.participant.sendRequest(
       headers, sendTo, callbackEndpointType, RestMethods.PUT, payload, options
     )
-    this.log.verbose('sendSuccessCallback is done', { sendTo, payload })
+    this.log.verbose('sendSuccessCallback is sent', { sendTo, payload })
   }
 
   async #updateOracleWithParticipantMapping ({ source, headers, params }) {
-    this.deps.stepState.inProgress('#updateOracleWithParticipantMapping-3')
+    this.stepInProgress('#updateOracleWithParticipantMapping-3')
     const mappingPayload = {
       fspId: source
     }

package/test/fixtures/index.js

@@ -1,3 +1,30 @@
+/*****
+ 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 { randomUUID } = require('node:crypto')
 const { Enum } = require('@mojaloop/central-services-shared')
 const isoFixtures = require('./iso')
@@ -20,6 +47,16 @@ const headersDto = ({
   'content-type': contentType || accept
 })
 
+const partiesParamsDto = ({
+  Type = 'MSISDN',
+  ID = String(Date.now()),
+  SubId
+} = {}) => ({
+  Type,
+  ID,
+  ...(SubId && { SubId })
+})
+
 const protocolVersionsDto = () => ({
   CONTENT: {
     DEFAULT: '2.1',
@@ -142,6 +179,7 @@ const mockHapiRequestDto = ({ // https://hapi.dev/api/?v=21.3.3#request-properti
 module.exports = {
   ...isoFixtures,
   partiesCallHeadersDto,
+  partiesParamsDto,
   participantsCallHeadersDto,
   oracleRequestResponseDto,
   putPartiesSuccessResponseDto,

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(3).lastArg).toEqual(cbError)
+      expect(logStub.getCall(2).lastArg).toEqual(cbError)
     })
 
     it('handles error when `oracleBatchRequest` returns no result', async () => {