account-lookup-service 17.7.1 → 17.8.0-snapshot.7

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

@@ -25,207 +25,135 @@
  --------------
  ******/
 
-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()
 
     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 })
-      return
+      const isDone = await this.processOraclePartyListResponse(response)
+      if (isDone) 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('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
     }
-
-    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 })
+    log.info('source is added to proxyMapping cache')
     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')
-    const callbackEndpointType = this.deps.partiesUtils.getPartyCbType(params.SubId)
-    let filteredResponsePartyList
-
-    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
-    }
-
-    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)
-    }
-
-    return filteredResponsePartyList
+  async sendOracleDiscoveryRequest () {
+    this.stepInProgress('#sendOracleDiscoveryRequest')
+    const { headers, params, query } = this.inputs
+    return this.deps.oracle.oracleRequest(headers, RestMethods.GET, params, query, undefined, this.deps.cache)
   }
 
-  async processOraclePartyList ({ partyList, headers, params, destination }) {
-    const log = this.log.child({ method: 'processOraclePartyList' })
+  async processOraclePartyListResponse (response) {
+    this.stepInProgress('processOraclePartyList')
+    const partyList = this.#filterOraclePartyList(response)
 
-    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
-        })
-      }
+    let sentCount = 0
+    await Promise.all(partyList.map(async party => {
+      const isSent = await this.#processSingleOracleParty(party)
+      if (isSent) sentCount++
+    }))
 
-      // 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
+    const isDone = sentCount > 0
+    this.log.verbose('processOraclePartyList is done', { isDone, sentCount })
+    // if NOT isDone, need to trigger interScheme discovery flow
+    return isDone
   }
 
-  async getFilteredProxyList (proxy) {
-    this.deps.stepState.inProgress('getAllProxies-8')
-    if (!this.proxyEnabled) {
-      this.log.warn('proxyCache is not enabled')
-      return []
-    }
+  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.deps.proxies.getAllProxiesNames(this.deps.config.SWITCH_ENDPOINT)
-    this.log.debug('getAllProxiesNames is done', { proxyNames })
-    return proxyNames.filter(name => name !== proxy)
-  }
+    const proxyNames = await this.#getFilteredProxyList(proxy)
+    if (!proxyNames.length) {
+      return this.#sendPartyNotFoundErrorCallback(headers)
+    }
 
-  async triggerSendToProxiesFlow ({ proxyNames, headers, params, source }) {
-    const log = this.log.child({ method: 'triggerSendToProxiesFlow' })
-    this.deps.stepState.inProgress('setSendToProxiesList-10')
+    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')
     const sending = proxyNames.map(
       sendTo => this.#forwardGetPartiesRequest({ sendTo, headers, params })
         .then(({ status, data } = {}) => ({ status, data }))
@@ -234,48 +162,150 @@ 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')
+    // todo: If forwarding request to proxy failed, remove the proxy from setSendToProxiesList
+    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)
+  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 callbackHeaders = GetPartiesService.createErrorCallbackHeaders(headers, params)
+    const fspiopError = super.createFspiopIdNotFoundError('No proxy found to start inter-scheme discovery flow')
+    const errorInfo = await this.deps.partiesUtils.makePutPartiesErrorPayload(
+      this.deps.config, fspiopError, callbackHeaders, params
+    )
 
     await this.sendErrorCallback({
-      sendTo: requester,
-      errorInfo: fspiopError.toApiErrorObject(this.deps.config.ERROR_HANDLING),
+      errorInfo,
       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.deps.stepState.inProgress('forwardRequest-3')
+    this.stepInProgress('#forwardGetPartiesRequest')
     const callbackEndpointType = this.deps.partiesUtils.getPartyCbType(params.SubId)
     const options = this.deps.partiesUtils.partiesRequestOptionsDto(params)
 
-    return this.deps.participant.sendRequest(headers, sendTo, callbackEndpointType, RestMethods.GET, undefined, options, this.deps.childSpan)
+    const sentResult = await this.deps.participant.sendRequest(
+      headers, sendTo, callbackEndpointType, RestMethods.GET, undefined, options, this.deps.childSpan
+    )
+    await this.#setProxyGetPartiesTimeout(sendTo)
+    return sentResult
+  }
+
+  async #getFilteredProxyList (proxy) {
+    this.stepInProgress('#getFilteredProxyList')
+    if (!this.state.proxyEnabled) {
+      this.log.warn('proxyCache is not enabled')
+      return []
+    }
+
+    const proxyNames = await this.deps.proxies.getAllProxiesNames(this.deps.config.SWITCH_ENDPOINT)
+    this.log.debug('getAllProxiesNames is done', { proxyNames })
+    return proxyNames.filter(name => name !== proxy)
+  }
+
+  async #setProxyGetPartiesTimeout (sendTo) {
+    const isLocalSource = this.isLocalSource()
+    const isSentToProxy = this.state.destination !== sendTo
+    this.log.verbose('isLocalSource and isSentToProxy: ', { isLocalSource, isSentToProxy, 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
+    }
   }
 }
 
 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,49 +30,73 @@ 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)
+  /** @returns {Promise<true | undefined>} - If true, need to trigger inter-scheme discovery. */
+  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
+      }
     }
-    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 })
   }
 }