account-lookup-service 17.7.0-snapshot.4 → 17.7.0

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

@@ -25,135 +25,207 @@
  --------------
  ******/
 
+const ErrorHandler = require('@mojaloop/central-services-error-handling')
 const { ERROR_MESSAGES } = require('../../../constants')
+const { createCallbackHeaders } = require('../../../lib/headers')
 const BasePartiesService = require('./BasePartiesService')
 
-const { FspEndpointTypes, RestMethods } = BasePartiesService.enums()
+const {
+  FspEndpointTypes, FspEndpointTemplates,
+  Headers, RestMethods
+} = BasePartiesService.enums()
+
 const proxyCacheTtlSec = 40 // todo: make configurable
 
 class GetPartiesService extends BasePartiesService {
-  async handleRequest () {
-    const { destination, source, proxy } = this.state
+  async handleRequest ({ headers, params, query, results }) {
+    const source = headers[Headers.FSPIOP.SOURCE]
+    const proxy = headers[Headers.FSPIOP.PROXY]
+    const destination = headers[Headers.FSPIOP.DESTINATION]
     // 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 })
-    this.state.requester = await this.validateRequester()
+    this.log.info('handling getParties request', { source, destination, proxy })
+
+    const requester = await this.validateRequester({ source, proxy })
+    results.requester = requester
 
     if (destination) {
-      await this.forwardRequestToDestination()
+      await this.forwardRequestToDestination({ destination, headers, params })
       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 isDone = await this.processOraclePartyListResponse(response)
-      if (isDone) return
+      const partyList = this.filterOraclePartyList({ response, params })
+      await this.processOraclePartyList({ partyList, headers, params, destination })
+      return
     }
 
-    this.log.info('no forwarded requests for oracle partyList')
-    const fspiopError = await this.triggerInterSchemeDiscoveryFlow(this.inputs.headers)
-    if (fspiopError) {
-      this.state.fspiopError = fspiopError // todo: think, if we need this
+    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
     }
+
+    results.fspiopError = await this.sendPartyNotFoundErrorCallback({ requester, headers, params })
   }
 
-  async validateRequester () {
-    const { source, proxy, proxyEnabled } = this.state
+  async validateRequester ({ source, proxy }) {
+    this.deps.stepState.inProgress('validateRequester-0')
     const log = this.log.child({ source, proxy, method: 'validateRequester' })
-    this.stepInProgress('validateRequester-0')
 
-    const schemeSource = await this.validateParticipant(source)
-    if (schemeSource) {
-      log.debug('source participant is in scheme')
+    const sourceParticipant = await this.validateParticipant(source)
+    if (sourceParticipant) {
+      log.debug('source is in scheme')
       return source
     }
 
-    if (!proxyEnabled || !proxy) {
-      throw super.createFspiopIdNotFoundError(ERROR_MESSAGES.sourceFspNotFound, log)
+    if (!this.proxyEnabled || !proxy) {
+      const errMessage = ERROR_MESSAGES.sourceFspNotFound
+      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 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 isCached = await this.deps.proxyCache.addDfspIdToProxyMapping(source, proxy)
     if (!isCached) {
-      throw super.createFspiopIdNotFoundError('failed to addDfspIdToProxyMapping', log)
+      const errMessage = 'failed to addDfspIdToProxyMapping'
+      log.warn(errMessage)
+      throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
     }
 
-    log.info('source is added to proxyMapping cache')
+    log.info('source is added to proxyMapping cache:', { proxy, isCached })
     return proxy
   }
 
-  async forwardRequestToDestination () {
-    const { headers, params } = this.inputs
-    const { destination } = this.state
+  async forwardRequestToDestination ({ destination, headers, params }) {
+    this.deps.stepState.inProgress('validateDestination-1')
     const log = this.log.child({ method: 'forwardRequestToDestination' })
     let sendTo = destination
 
-    const schemeParticipant = await this.validateParticipant(destination)
-    if (!schemeParticipant) {
-      this.stepInProgress('lookupProxyDestination-2')
-      const proxyId = this.state.proxyEnabled && await this.deps.proxyCache.lookupProxyByDfspId(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)
 
       if (!proxyId) {
-        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
+        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)
       }
       sendTo = proxyId
     }
-
+    // all ok, go ahead and forward the request
     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)
-  }
+  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)
+    let filteredResponsePartyList
 
-  async processOraclePartyListResponse (response) {
-    this.stepInProgress('processOraclePartyList')
-    const partyList = this.#filterOraclePartyList(response)
+    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
+        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
+        break
+      default:
+        filteredResponsePartyList = response // Fallback to providing the standard list
+    }
 
-    let sentCount = 0
-    await Promise.all(partyList.map(async party => {
-      const isSent = await this.#processSingleOracleParty(party)
-      if (isSent) sentCount++
-    }))
+    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)
+    }
 
-    const isDone = sentCount > 0
-    this.log.verbose('processOraclePartyList is done', { isDone, sentCount })
-    // if NOT isDone, need to trigger interScheme discovery flow
-    return isDone
+    return filteredResponsePartyList
   }
 
-  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 })
+  async processOraclePartyList ({ partyList, headers, params, destination }) {
+    const log = this.log.child({ method: 'processOraclePartyList' })
 
-    const proxyNames = await this.#getFilteredProxyList(proxy)
-    if (!proxyNames.length) {
-      return this.#sendPartyNotFoundErrorCallback(headers)
+    let sentCount = 0 // if sentCount === 0 after sending, should we restart the whole process?
+    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 })
+        return this.#forwardGetPartiesRequest({
+          sendTo: fspId,
+          headers: clonedHeaders,
+          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')
+        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 {
+          sentCount++
+          log.info('participant is NOT in scheme, use proxy name', { fspId, proxyName })
+          return this.#forwardGetPartiesRequest({
+            sendTo: proxyName,
+            headers: clonedHeaders,
+            params
+          })
+        }
+      }
+    })
+    await Promise.all(sending)
+    log.verbose('processOraclePartyList is done', { sentCount })
+    // todo: think what if sentCount === 0 here
+  }
+
+  async getFilteredProxyList (proxy) {
+    this.deps.stepState.inProgress('getAllProxies-8')
+    if (!this.proxyEnabled) {
+      this.log.warn('proxyCache is not enabled')
+      return []
     }
 
-    this.stepInProgress('setSendToProxiesList-10')
+    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)
-    log.verbose('starting setSendToProxiesList flow: ', { proxyNames, alsReq, proxyCacheTtlSec })
+    log.info('starting setSendToProxiesList flow: ', { proxyNames, alsReq, proxyCacheTtlSec })
 
     const isCached = await this.deps.proxyCache.setSendToProxiesList(alsReq, proxyNames, proxyCacheTtlSec)
     if (!isCached) {
-      throw super.createFspiopIdNotFoundError(ERROR_MESSAGES.failedToCacheSendToProxiesList, log)
+      log.warn('failed to setSendToProxiesList')
+      throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, ERROR_MESSAGES.failedToCacheSendToProxiesList)
     }
 
-    this.stepInProgress('sendingProxyRequests')
+    this.deps.stepState.inProgress('sendingProxyRequests-11')
     const sending = proxyNames.map(
       sendTo => this.#forwardGetPartiesRequest({ sendTo, headers, params })
         .then(({ status, data } = {}) => ({ status, data }))
@@ -162,145 +234,48 @@ 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
-    log.info('triggerInterSchemeDiscoveryFlow is done:', { isOk, results, proxyNames, alsReq })
-    this.stepInProgress('allSent-12')
-
+    // 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')
     if (!isOk) {
-      throw super.createFspiopIdNotFoundError(ERROR_MESSAGES.proxyConnectionError, log)
+      log.warn('no successful requests sent to proxies')
+      throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, ERROR_MESSAGES.proxyConnectionError)
     }
   }
 
-  isLocalSource () {
-    const isLocal = this.state.source === this.state.requester
-    this.log.debug(`isLocalSource: ${isLocal}`)
-    return isLocal
-  }
-
-  #filterOraclePartyList (response) {
-    // Oracle's API is a standard rest-style end-point Thus a GET /party on the oracle will return all participant-party records.
-    // We must filter the results based on the callbackEndpointType to make sure we remove records containing partySubIdOrType when we are in FSPIOP_CALLBACK_URL_PARTIES_GET mode:
-    this.stepInProgress('filterOraclePartyList')
-    const { params } = this.inputs
-    const callbackEndpointType = this.deps.partiesUtils.getPartyCbType(params.SubId)
-    let filteredPartyList
-
-    switch (callbackEndpointType) {
-      case FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTIES_GET:
-        filteredPartyList = response.data.partyList.filter(party => party.partySubIdOrType == null) // Filter records that DON'T contain a partySubIdOrType
-        break
-      case FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTIES_SUB_ID_GET:
-        filteredPartyList = response.data.partyList.filter(party => party.partySubIdOrType === params.SubId) // Filter records that match partySubIdOrType
-        break
-      default:
-        filteredPartyList = response // Fallback to providing the standard list
-    }
-
-    if (!Array.isArray(filteredPartyList) || !filteredPartyList.length) {
-      throw super.createFspiopIdNotFoundError(ERROR_MESSAGES.emptyFilteredPartyList)
-    }
-
-    return filteredPartyList
-  }
-
-  /** @returns {Promise<boolean>} - is request forwarded to participant */
-  async #processSingleOracleParty (party) {
-    const { headers, params } = this.inputs
-    const { fspId } = party
-
-    const schemeParticipant = await this.validateParticipant(fspId)
-    if (schemeParticipant) {
-      this.log.info('participant is in scheme, so forwarding to it...', { fspId })
-      await this.#forwardGetPartiesRequest({
-        sendTo: fspId,
-        headers: GetPartiesService.overrideDestinationHeader(headers, fspId),
-        params
-      })
-      return true
-    }
-
-    if (this.state.proxyEnabled) {
-      const proxyName = await this.deps.proxyCache.lookupProxyByDfspId(fspId)
-      if (!proxyName) {
-        this.log.warn('no proxyMapping for external DFSP!  Deleting reference in oracle...', { fspId })
-        await super.sendDeleteOracleRequest(headers, params)
-        // todo: check if it won't delete all parties
-        return false
-      }
-
-      // Coz there's no destination header, it means we're inside initial inter-scheme discovery phase.
-      // So we should proceed only if source is in scheme (local participant)
-      const isLocalSource = this.isLocalSource()
-      if (isLocalSource) {
-        this.log.info('participant is NOT in scheme, but source is. So forwarding to proxy...', { fspId, proxyName })
-        await this.#forwardGetPartiesRequest({ // todo: add timeout if sendTo is proxy
-          sendTo: proxyName,
-          headers: GetPartiesService.overrideDestinationHeader(headers, fspId),
-          params
-        })
-        return true
-      }
-    }
-    return false
-  }
-
-  async #sendPartyNotFoundErrorCallback (headers) {
-    const { params } = this.inputs
-    const fspiopError = super.createFspiopIdNotFoundError('No proxy found to start inter-scheme discovery flow')
+  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)
 
     await this.sendErrorCallback({
+      sendTo: requester,
       errorInfo: fspiopError.toApiErrorObject(this.deps.config.ERROR_HANDLING),
-      headers: GetPartiesService.createErrorCallbackHeaders(headers, params),
+      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)
+  }
+
   async #forwardGetPartiesRequest ({ sendTo, headers, params }) {
-    this.stepInProgress('#forwardGetPartiesRequest')
+    this.deps.stepState.inProgress('forwardRequest-3')
     const callbackEndpointType = this.deps.partiesUtils.getPartyCbType(params.SubId)
     const options = this.deps.partiesUtils.partiesRequestOptionsDto(params)
 
-    const sentResult = await this.deps.participant.sendRequest(
-      headers, sendTo, callbackEndpointType, RestMethods.GET, undefined, options, this.deps.childSpan
-    )
-    await this.#setProxyGetPartiesTimeout(sendTo)
-    return sentResult
-  }
-
-  async #getFilteredProxyList (proxy) {
-    this.stepInProgress('#getFilteredProxyList')
-    if (!this.state.proxyEnabled) {
-      this.log.warn('proxyCache is not enabled')
-      return []
-    }
-
-    const proxyNames = await this.deps.proxies.getAllProxiesNames(this.deps.config.SWITCH_ENDPOINT)
-    this.log.debug('getAllProxiesNames is done', { proxyNames })
-    return proxyNames.filter(name => name !== proxy)
-  }
-
-  async #setProxyGetPartiesTimeout (sendTo) {
-    const isLocalSource = this.isLocalSource()
-    const isSentToProxy = this.state.destination !== sendTo
-    this.log.verbose('isLocalSource and isSentToProxy: ', { isLocalSource, isSentToProxy, sendTo })
-
-    if (isSentToProxy && isLocalSource) {
-      this.stepInProgress('#setProxyGetPartiesTimeout')
-      const alsReq = this.deps.partiesUtils.alsRequestDto(this.state.source, this.inputs.params)
-      const isSet = await this.deps.proxyCache.setProxyGetPartiesTimeout(alsReq, sendTo)
-      this.log.info('#setProxyGetPartiesTimeout is done', { isSet })
-      return isSet
-    }
+    return this.deps.participant.sendRequest(headers, sendTo, callbackEndpointType, RestMethods.GET, undefined, options, this.deps.childSpan)
   }
 }
 
 module.exports = GetPartiesService
-
-// As Payee DFSP Scheme Oracle identifies direct participant.
-// As Payer DFSP Scheme oracle identifies interscheme participant.
-
-// zm-dfsp --> ZM
-// region-dfsp --> Region
-// mw-dfsp --> MW  (mw-party-123)
-
-// 1. region-dfsp gets info about mw-party-123

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

@@ -30,72 +30,49 @@ const { ERROR_MESSAGES } = require('../../../constants')
 const BasePartiesService = require('./BasePartiesService')
 
 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 isPending = await this.deps.proxyCache.isPendingCallback(alsReq)
-
-      if (!isPending) {
-        // not initial inter-scheme discovery case. Cleanup oracle and trigger inter-scheme discovery
-        this.log.warn('Need to cleanup oracle and trigger new inter-scheme discovery flow')
-        await this.cleanupOracle()
-        await this.removeProxyGetPartiesTimeoutCache(alsReq)
-        return true // need to trigger inter-scheme discovery
-      }
-
-      const isLast = await this.checkLastProxyCallback(alsReq)
-      if (!isLast) {
-        this.log.verbose('putPartiesErrorByTypeAndID proxy callback was processed')
-        return
-      }
+  // 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)
     }
-
-    await this.identifyDestinationForErrorCallback()
-    await this.sendErrorCallbackToParticipant()
-    this.log.info('putPartiesByTypeAndID is done')
+    return notValid
   }
 
-  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
+  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 () {
-    this.stepInProgress('identifyDestinationForErrorCallback')
-    const { destination } = this.state
-    const schemeParticipant = await super.validateParticipant(destination)
-    if (schemeParticipant) {
-      this.state.requester = destination
-      return
-    }
+  async identifyDestinationForErrorCallback (destination) {
+    this.deps.stepState.inProgress('validateParticipant-3')
+    const destinationParticipant = await super.validateParticipant(destination)
+    if (destinationParticipant) return destination
 
-    this.stepInProgress('lookupProxyDestination-4')
-    const proxyName = this.state.proxyEnabled && await this.deps.proxyCache.lookupProxyByDfspId(destination)
-    if (proxyName) {
-      this.state.requester = proxyName
-      return
-    }
+    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 () {
-    const { headers, params, dataUri } = this.inputs
+  async sendErrorCallbackToParticipant ({ sendTo, headers, params, dataUri }) {
+    this.deps.stepState.inProgress('sendErrorToParticipant-5')
     const errorInfo = PutPartiesErrorService.decodeDataUriPayload(dataUri)
-    return super.sendErrorCallback({ errorInfo, headers, params })
+    return super.sendErrorCallback({
+      sendTo, errorInfo, headers, params
+    })
   }
 }