account-lookup-service 15.5.0-iso.0

package/src/domain/parties/getPartiesByTypeAndID.js

@@ -0,0 +1,239 @@
+/*****
+ License
+ --------------
+ Copyright © 2017 Bill & Melinda Gates Foundation
+ The Mojaloop files are made available by the Bill & Melinda Gates 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
+ Gates Foundation organization 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>.
+ * Gates Foundation
+ - Name Surname <name.surname@gatesfoundation.com>
+
+ * Eugen Klymniuk <eugen.klymniuk@infitx.com>
+ --------------
+ **********/
+
+const { Enum, Util } = require('@mojaloop/central-services-shared')
+const ErrorHandler = require('@mojaloop/central-services-error-handling')
+const Metrics = require('@mojaloop/central-services-metrics')
+
+const config = require('../../lib/config')
+const oracle = require('../../models/oracle/facade')
+const participant = require('../../models/participantEndpoint/facade')
+const { createCallbackHeaders } = require('../../lib/headers')
+const { ERROR_MESSAGES } = require('../../constants')
+const { loggerFactory } = require('../../lib')
+const Config = require('../../lib/config')
+const utils = require('./utils')
+
+const { FspEndpointTypes, FspEndpointTemplates } = Enum.EndPoints
+const { Headers, RestMethods } = Enum.Http
+
+const logger = loggerFactory('domain:get-parties')
+
+const proxyCacheTtlSec = 40 // todo: make configurable
+
+const validateRequester = async ({ source, proxy, proxyCache }) => {
+  const sourceParticipant = await participant.validateParticipant(source)
+  if (sourceParticipant) {
+    logger.debug('source is in scheme', { source })
+    return source
+  }
+
+  if (!proxy) {
+    const errMessage = ERROR_MESSAGES.partySourceFspNotFound
+    throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
+  }
+
+  const proxyParticipant = await participant.validateParticipant(proxy)
+  if (!proxyParticipant) {
+    const errMessage = ERROR_MESSAGES.partyProxyNotFound
+    throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
+  }
+
+  const isCached = await proxyCache.addDfspIdToProxyMapping(source, proxy)
+  // think, what if isCached !== true?
+  logger.info('source is added to proxyMapping cache:', { source, proxy, isCached })
+  return proxy
+}
+
+/**
+ * @function getPartiesByTypeAndID
+ *
+ * @description sends request to applicable oracle based on type and sends results to a callback url
+ *
+ * @param {object} headers - incoming http request headers
+ * @param {object} params - uri parameters of the http request
+ * @param {string} method - http request method
+ * @param {object} query - uri query parameters of the http request
+ * @param {object} span
+ * @param {object} cache
+ * @param {IProxyCache} [proxyCache] - IProxyCache instance
+ */
+const getPartiesByTypeAndID = async (headers, params, method, query, span, cache, proxyCache = undefined) => {
+  const histTimerEnd = Metrics.getHistogram(
+    'getPartiesByTypeAndID',
+    'Get party by Type and Id',
+    ['success']
+  ).startTimer()
+  const proxyEnabled = !!(Config.PROXY_CACHE_CONFIG.enabled && proxyCache)
+  const type = params.Type
+  const partySubId = params.SubId
+  const source = headers[Headers.FSPIOP.SOURCE]
+  const proxy = proxyEnabled && headers[Headers.FSPIOP.PROXY]
+  const callbackEndpointType = utils.getPartyCbType(partySubId)
+
+  const childSpan = span ? span.getChild('getPartiesByTypeAndID') : undefined
+  logger.info('parties::getPartiesByTypeAndID::begin', { source, proxy, params })
+
+  let requester
+  let fspiopError
+
+  try {
+    requester = await validateRequester({ source, proxy, proxyCache })
+
+    const options = {
+      partyIdType: type,
+      partyIdentifier: params.ID,
+      ...(partySubId && { partySubIdOrType: partySubId })
+    }
+
+    let 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.
+    if (destination) {
+      const destParticipantModel = await participant.validateParticipant(destination)
+      if (!destParticipantModel) {
+        const proxyId = proxyEnabled && await proxyCache.lookupProxyByDfspId(destination)
+
+        if (!proxyId) {
+          const errMessage = ERROR_MESSAGES.partyDestinationFspNotFound
+          throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
+        }
+        destination = proxyId
+      }
+      // all ok, go ahead and forward the request
+      await participant.sendRequest(headers, destination, callbackEndpointType, RestMethods.GET, undefined, options, childSpan)
+
+      histTimerEnd({ success: true })
+      logger.info('discovery getPartiesByTypeAndID request was sent to destination', { destination })
+      return
+    }
+
+    const response = await oracle.oracleRequest(headers, method, params, query, undefined, cache)
+    if (Array.isArray(response?.data?.partyList) && response.data.partyList.length > 0) {
+      // 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:
+      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 === partySubId) // 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'
+        throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
+      }
+
+      let sentCount = 0 // if sentCount === 0 after sending, should we restart the whole process?
+      const sending = filteredResponsePartyList.map(async party => {
+        const { fspId } = party
+        const clonedHeaders = { ...headers }
+        if (!destination) {
+          clonedHeaders[Headers.FSPIOP.DESTINATION] = fspId
+        }
+        const schemeParticipant = await participant.validateParticipant(fspId)
+        if (schemeParticipant) {
+          sentCount++
+          logger.debug('participant is in scheme', { fspId })
+          return participant.sendRequest(clonedHeaders, party.fspId, callbackEndpointType, RestMethods.GET, undefined, options, childSpan)
+        }
+
+        // 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 (proxyEnabled) {
+          const proxyName = await proxyCache.lookupProxyByDfspId(fspId)
+          if (!proxyName) {
+            logger.warn('no proxyMapping for participant!  TODO: Delete reference in oracle...', { fspId })
+            // todo: delete reference in oracle
+          } else {
+            sentCount++
+            logger.debug('participant NOT is in scheme, use proxy name', { fspId, proxyName })
+            return participant.sendRequest(clonedHeaders, proxyName, callbackEndpointType, RestMethods.GET, undefined, options, childSpan)
+          }
+        }
+      })
+      await Promise.all(sending)
+      logger.info('participant.sendRequests to filtered oracle partyList are done', { sentCount })
+      // todo: think what if sentCount === 0 here
+    } else {
+      logger.info('empty partyList form oracle, getting proxies list...', { proxyEnabled, params })
+      let filteredProxyNames = []
+
+      if (proxyEnabled) {
+        const proxyNames = await Util.proxies.getAllProxiesNames(Config.SWITCH_ENDPOINT)
+        filteredProxyNames = proxyNames.filter(name => name !== proxy)
+      }
+
+      if (!filteredProxyNames.length) {
+        const callbackHeaders = createCallbackHeaders({
+          requestHeaders: headers,
+          partyIdType: type,
+          partyIdentifier: params.ID,
+          endpointTemplate: partySubId
+            ? FspEndpointTemplates.PARTIES_SUB_ID_PUT_ERROR
+            : FspEndpointTemplates.PARTIES_PUT_ERROR
+        })
+        fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.PARTY_NOT_FOUND)
+        const errorCallbackEndpointType = utils.errorPartyCbType(partySubId)
+        await participant.sendErrorToParticipant(requester, errorCallbackEndpointType,
+          fspiopError.toApiErrorObject(config.ERROR_HANDLING), callbackHeaders, params, childSpan)
+      } else {
+        const alsReq = utils.alsRequestDto(source, params)
+        logger.info('starting setSendToProxiesList flow: ', { filteredProxyNames, alsReq, proxyCacheTtlSec })
+        const isCached = await proxyCache.setSendToProxiesList(alsReq, filteredProxyNames, proxyCacheTtlSec)
+        if (!isCached) {
+          throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, ERROR_MESSAGES.failedToCacheSendToProxiesList)
+        }
+
+        const sending = filteredProxyNames.map(
+          proxyName => participant.sendRequest(headers, proxyName, callbackEndpointType, RestMethods.GET, undefined, options, childSpan)
+            .then(({ status, data } = {}) => ({ status, data }))
+        )
+        const results = await Promise.allSettled(sending)
+        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)
+        logger.info('setSendToProxiesList flow is done:', { isOk, results, filteredProxyNames, alsReq })
+        if (!isOk) {
+          throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, ERROR_MESSAGES.proxyConnectionError)
+        }
+      }
+    }
+    histTimerEnd({ success: true })
+  } catch (err) {
+    fspiopError = await utils.handleErrorOnSendingCallback(err, headers, params, requester)
+    histTimerEnd({ success: false })
+  } finally {
+    await utils.finishSpanWithError(childSpan, fspiopError)
+  }
+}
+
+module.exports = getPartiesByTypeAndID

package/src/domain/parties/index.js

@@ -0,0 +1,32 @@
+/*****
+ License
+ --------------
+ Copyright © 2017 Bill & Melinda Gates Foundation
+ The Mojaloop files are made available by the Bill & Melinda Gates 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
+ Gates Foundation organization 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>.
+ * Gates Foundation
+ - Name Surname <name.surname@gatesfoundation.com>
+
+ - Rajiv Mothilal <rajiv.mothilal@modusbox.com>
+
+ --------------
+ ******/
+
+'use strict'
+
+const parties = require('./parties')
+
+exports.getPartiesByTypeAndID = parties.getPartiesByTypeAndID
+exports.putPartiesByTypeAndID = parties.putPartiesByTypeAndID
+exports.putPartiesErrorByTypeAndID = parties.putPartiesErrorByTypeAndID

package/src/domain/parties/parties.js

@@ -0,0 +1,215 @@
+/*****
+ License
+ --------------
+ Copyright © 2017 Bill & Melinda Gates Foundation
+ The Mojaloop files are made available by the Bill & Melinda Gates 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
+ Gates Foundation organization 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>.
+ * Gates Foundation
+ - Name Surname <name.surname@gatesfoundation.com>
+
+ - Rajiv Mothilal <rajiv.mothilal@modusbox.com>
+ - Henk Kodde <henk.kodde@modusbox.com>
+ - Steven Oderayi <steven.oderayi@modusbox.com>
+ - Juan Correa <juan.correa@modusbox.com>
+ - James Bush <james.bush@modusbox.com>
+
+ --------------
+ ******/
+
+'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 Metrics = require('@mojaloop/central-services-metrics')
+
+const oracle = require('../../models/oracle/facade')
+const participant = require('../../models/participantEndpoint/facade')
+const { ERROR_MESSAGES } = require('../../constants')
+const { loggerFactory } = require('../../lib')
+const Config = require('../../lib/config')
+const utils = require('./utils')
+const getPartiesByTypeAndID = require('./getPartiesByTypeAndID')
+
+const logger = loggerFactory('domain:put-parties')
+
+/**
+ * @function putPartiesByTypeAndID
+ *
+ * @description This sends a callback to inform participant of successful lookup
+ *
+ * @param {object} headers - incoming http request headers
+ * @param {object} params - uri parameters of the http request
+ * @param {string} method - http request method
+ * @param {object} payload - payload of the request being sent out
+ * @param {string} dataUri - encoded payload of the request being sent out
+ * @param {CacheClient} cache - in-memory cache with CatboxMemory engine
+ * @param {IProxyCache} [proxyCache] - IProxyCache instance
+ */
+const putPartiesByTypeAndID = async (headers, params, method, payload, dataUri, cache, proxyCache = undefined) => {
+  const histTimerEnd = Metrics.getHistogram(
+    'putPartiesByTypeAndID',
+    'Put parties by type and id',
+    ['success']
+  ).startTimer()
+  const type = params.Type
+  const partySubId = params.SubId
+  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)
+  logger.info('parties::putPartiesByTypeAndID::begin', { source, destination, proxy, params })
+
+  let sendTo
+  try {
+    const requesterParticipant = await participant.validateParticipant(source)
+    if (!requesterParticipant) {
+      if (!proxyEnabled || !proxy) {
+        const errMessage = ERROR_MESSAGES.partySourceFspNotFound
+        throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
+      }
+      const isCached = await proxyCache.addDfspIdToProxyMapping(source, proxy)
+      // think,if we should throw error if isCached === false?
+      logger.info('addDfspIdToProxyMapping is done', { source, proxy, isCached })
+    }
+
+    if (proxyEnabled && proxy) {
+      const alsReq = utils.alsRequestDto(destination, params) // or source?
+      const isExists = await proxyCache.receivedSuccessResponse(alsReq)
+      if (!isExists) {
+        logger.warn('destination is NOT in scheme, and no cached sendToProxiesList', { destination, alsReq })
+        // think, if we need to throw an error here
+      } else {
+        const mappingPayload = {
+          fspId: source
+        }
+        await oracle.oracleRequest(headers, RestMethods.POST, params, null, mappingPayload, cache)
+        logger.info('oracle was updated with mappingPayload', { mappingPayload, params })
+      }
+    }
+
+    const destinationParticipant = await participant.validateParticipant(destination)
+    if (!destinationParticipant) {
+      const proxyName = proxyEnabled && await proxyCache.lookupProxyByDfspId(destination)
+      if (!proxyName) {
+        const errMessage = ERROR_MESSAGES.partyDestinationFspNotFound
+        throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.DESTINATION_FSP_ERROR, errMessage)
+      }
+      sendTo = proxyName
+    } else {
+      sendTo = destinationParticipant.name
+    }
+
+    const decodedPayload = decodePayload(dataUri, { asParsed: false })
+    const callbackEndpointType = utils.putPartyCbType(partySubId)
+    const options = {
+      partyIdType: type,
+      partyIdentifier: params.ID,
+      ...(partySubId && { partySubIdOrType: partySubId })
+    }
+    await participant.sendRequest(headers, sendTo, callbackEndpointType, RestMethods.PUT, decodedPayload.body.toString(), options)
+
+    logger.info('parties::putPartiesByTypeAndID::callback was sent', { sendTo, options })
+    histTimerEnd({ success: true })
+  } catch (err) {
+    await utils.handleErrorOnSendingCallback(err, headers, params, sendTo)
+    histTimerEnd({ success: false })
+  }
+}
+
+/**
+ * @function putPartiesErrorByTypeAndID
+ *
+ * @description This populates the cache of endpoints
+ *
+ * @param {object} headers - incoming http request headers
+ * @param {object} params - uri parameters of the http request
+ * @param {object} payload - payload of the request being sent out
+ * @param {string} dataUri - encoded payload of the request being sent out
+ * @param {object} span
+ * @param {CacheClient} cache - in-memory cache with CatboxMemory engine
+ * @param {IProxyCache} [proxyCache] - IProxyCache instance
+ */
+const putPartiesErrorByTypeAndID = async (headers, params, payload, dataUri, span, cache, proxyCache = undefined) => {
+  const histTimerEnd = Metrics.getHistogram(
+    'putPartiesErrorByTypeAndID',
+    'Put parties error by type and id',
+    ['success']
+  ).startTimer()
+  const partySubId = params.SubId
+  const destination = headers[Headers.FSPIOP.DESTINATION]
+  const callbackEndpointType = utils.errorPartyCbType(partySubId)
+  const proxyEnabled = !!(Config.PROXY_CACHE_CONFIG.enabled && proxyCache)
+
+  const childSpan = span ? span.getChild('putPartiesErrorByTypeAndID') : undefined
+
+  let sendTo
+  let fspiopError
+
+  try {
+    const proxy = proxyEnabled && headers[Headers.FSPIOP.PROXY]
+    if (proxy) {
+      if (isNotValidPayeeCase(payload)) {
+        const swappedHeaders = utils.swapSourceDestinationHeaders(headers)
+        await oracle.oracleRequest(swappedHeaders, RestMethods.DELETE, params, null, null, cache)
+        getPartiesByTypeAndID(swappedHeaders, params, RestMethods.GET, {}, span, cache, proxyCache)
+        // todo: - think if we need to send errorCallback?
+        //       - or sentCallback after getPartiesByTypeAndID is done
+        logger.info('notValidPayee case - deleted Participants and run getPartiesByTypeAndID:', { proxy, params, payload })
+        return
+      }
+
+      const alsReq = utils.alsRequestDto(destination, params) // or source?
+      const isLast = await proxyCache.receivedErrorResponse(alsReq, proxy)
+      if (!isLast) {
+        logger.info('got NOT last error callback from proxy:', { proxy, alsReq })
+        return
+      }
+    }
+
+    const destinationParticipant = await participant.validateParticipant(destination)
+
+    if (destinationParticipant) {
+      sendTo = destination
+    } else {
+      const proxyName = proxyEnabled && await proxyCache.lookupProxyByDfspId(destination)
+      if (!proxyName) {
+        const errMessage = ERROR_MESSAGES.partyDestinationFspNotFound
+        throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.DESTINATION_FSP_ERROR, errMessage)
+      }
+      sendTo = proxyName
+    }
+    const decodedPayload = decodePayload(dataUri, { asParsed: false })
+    await participant.sendErrorToParticipant(sendTo, callbackEndpointType, decodedPayload.body.toString(), headers, params, childSpan)
+
+    logger.info('putPartiesErrorByTypeAndID callback was sent', { sendTo })
+    histTimerEnd({ success: true })
+  } catch (err) {
+    fspiopError = await utils.handleErrorOnSendingCallback(err, headers, params, sendTo)
+    histTimerEnd({ success: false })
+  } finally {
+    await utils.finishSpanWithError(childSpan, fspiopError)
+  }
+}
+
+function isNotValidPayeeCase (payload) {
+  return payload?.errorInformation?.errorCode === MojaloopApiErrorCodes.PAYEE_IDENTIFIER_NOT_VALID.code
+}
+
+module.exports = {
+  getPartiesByTypeAndID,
+  putPartiesByTypeAndID,
+  putPartiesErrorByTypeAndID
+}

package/src/domain/parties/utils.js

@@ -0,0 +1,84 @@
+const { Enum } = require('@mojaloop/central-services-shared')
+const EventSdk = require('@mojaloop/event-sdk')
+const ErrorHandler = require('@mojaloop/central-services-error-handling')
+
+const participant = require('../../models/participantEndpoint/facade')
+const Config = require('../../lib/config')
+const { logger } = require('../../lib')
+
+const { FspEndpointTypes } = Enum.EndPoints
+const { Headers } = Enum.Http
+
+const getPartyCbType = (partySubId) => partySubId
+  ? FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTIES_SUB_ID_GET
+  : FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTIES_GET
+
+const putPartyCbType = (partySubId) => partySubId
+  ? FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTIES_SUB_ID_PUT
+  : FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTIES_PUT
+
+const errorPartyCbType = (partySubId) => partySubId
+  ? FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTIES_SUB_ID_PUT_ERROR
+  : FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTIES_PUT_ERROR
+
+const finishSpanWithError = async (childSpan, fspiopError) => {
+  if (childSpan && !childSpan.isFinished) {
+    if (fspiopError) {
+      const state = new EventSdk.EventStateMetadata(EventSdk.EventStatusType.failed, fspiopError.apiErrorCode.code, fspiopError.apiErrorCode.message)
+      await childSpan.error(fspiopError, state)
+      await childSpan.finish(fspiopError.message, state)
+    } else {
+      await childSpan.finish()
+    }
+  }
+}
+
+const alsRequestDto = (sourceId, params) => ({
+  sourceId,
+  type: params.Type,
+  partyId: params.ID
+})
+
+const swapSourceDestinationHeaders = (headers) => {
+  const {
+    [Headers.FSPIOP.SOURCE]: source,
+    [Headers.FSPIOP.DESTINATION]: destination,
+    [Headers.FSPIOP.PROXY]: proxy,
+    ...restHeaders
+  } = headers
+  return {
+    ...restHeaders,
+    [Headers.FSPIOP.SOURCE]: destination,
+    [Headers.FSPIOP.DESTINATION]: source
+  }
+}
+
+// change signature to accept object
+const handleErrorOnSendingCallback = async (err, headers, params, requester) => {
+  try {
+    logger.error('error in sending parties callback', err)
+    const sendTo = requester || headers[Headers.FSPIOP.SOURCE]
+    const errorCallbackEndpointType = errorPartyCbType(params.SubId)
+    const fspiopError = ErrorHandler.Factory.reformatFSPIOPError(err)
+    const errInfo = fspiopError.toApiErrorObject(Config.ERROR_HANDLING)
+
+    await participant.sendErrorToParticipant(sendTo, errorCallbackEndpointType, errInfo, headers, params)
+
+    logger.info('handleErrorOnSendingCallback in done', { sendTo, params, errInfo })
+    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.
+    logger.error('error in handleErrorOnSendingCallback', exc)
+  }
+}
+
+module.exports = {
+  getPartyCbType,
+  putPartyCbType,
+  errorPartyCbType,
+  finishSpanWithError,
+  handleErrorOnSendingCallback,
+  alsRequestDto,
+  swapSourceDestinationHeaders
+}

package/src/domain/timeout/dto.js

@@ -0,0 +1,48 @@
+const {
+  Factory: { createFSPIOPError },
+  Enums: { FSPIOPErrorCodes }
+} = require('@mojaloop/central-services-error-handling')
+const {
+  Http: { Headers: { FSPIOP: FSPIOPHeaders } },
+  Events: { Event: { Type: EventType, Action: EventAction } },
+  EndPoints: { FspEndpointTypes }
+} = require('@mojaloop/central-services-shared').Enum
+const { Tracer } = require('@mojaloop/event-sdk')
+const { API_TYPES } = require('@mojaloop/central-services-shared').Util.Hapi
+
+const { TransformFacades } = require('../../lib')
+const LibUtil = require('../../lib/util')
+const Config = require('../../lib/config')
+
+const makeErrorPayload = async (headers, params) => {
+  const body = createFSPIOPError(FSPIOPErrorCodes.EXPIRED_ERROR).toApiErrorObject(Config.ERROR_HANDLING)
+  return Config.API_TYPE === API_TYPES.iso20022
+    ? (await TransformFacades.FSPIOP.parties.putError({ body, headers, params })).body
+    : body
+}
+
+const timeoutCallbackDto = async ({ destination, partyId, partyType }) => {
+  const headers = {
+    [FSPIOPHeaders.SOURCE]: Config.HUB_NAME,
+    [FSPIOPHeaders.DESTINATION]: destination
+  }
+  const params = {
+    ID: partyId,
+    Type: partyType
+  }
+  const dto = {
+    errorInformation: await makeErrorPayload(headers, params),
+    headers,
+    params,
+    endpointType: FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTIES_PUT_ERROR
+  }
+  const span = Tracer.createSpan('timeoutInterschemePartiesLookups', { headers: dto.headers })
+  const spanTags = LibUtil.getSpanTags({ headers: dto.headers }, EventType.PARTY, EventAction.PUT)
+  span.setTags(spanTags)
+
+  return { ...dto, span }
+}
+
+module.exports = {
+  timeoutCallbackDto
+}