@mojaloop/sdk-scheme-adapter 11.18.8

package/OutboundServer/api_template/paths/authorizations.yaml

@@ -0,0 +1,19 @@
+post:
+  description: The HTTP request `POST /authorizations` is used to request the Payer to enter the applicable credentials in the PISP system.
+  summary: Authorizations endpoint
+  operationId: AuthorizationsPost
+  tags:
+    - authorizations
+  requestBody:
+    description: Perform authorization
+    required: true
+    content:
+      application/json:
+        schema:
+          $ref: '../components/schemas/authorizationsPostRequest.yaml'
+  responses:
+    200:
+      $ref: '../components/responses/authorizationPostSuccess.yaml'
+    500:
+      $ref: '../components/responses/authorizationsServerError.yaml'
+

package/OutboundServer/api_template/paths/bulkQuotes.yaml

@@ -0,0 +1,23 @@
+post:
+  summary: Request bulk quotes for the provided financial transactions
+  description: >
+    The HTTP request `POST /bulkQuotes` is used to request a bulk quote to
+    fascilitate funds transfer from payer DFSP to payees' DFSP.
+  tags:
+    - BulkQuotes
+  requestBody:
+    description: Bulk quote request body
+    content:
+      application/json:
+        schema:
+          $ref: ../components/schemas/bulkQuoteRequest.yaml
+    required: true
+  responses:
+    '200':
+      $ref: ../components/responses/bulkQuoteSuccess.yaml
+    '400':
+      $ref: ../components/responses/bulkQuoteBadRequest.yaml
+    '500':
+      $ref: ../components/responses/bulkQuoteServerError.yaml
+    '504':
+      $ref: ../components/responses/bulkQuoteTimeout.yaml

package/OutboundServer/api_template/paths/bulkQuotes_bulkQuoteId.yaml

@@ -0,0 +1,24 @@
+get:
+  summary: Retrieves information for a specific bulk quote
+  description: >-
+    The HTTP request `GET /bulkQuotes/{bulktQuoteId}` is used to get information
+    regarding a bulk quote created or requested earlier. The `{bulkQuoteId}` in
+    the URI should contain the `bulkQuoteId` that was used for the creation of
+    the bulk quote.
+  tags:
+    - BulkQuotes
+  parameters:
+    - $ref: ../components/parameters/bulkQuoteId.yaml
+  responses:
+    '200':
+      description: Bulk quote information successfully retrieved
+      content:
+        application/json:
+          schema:
+            $ref: ../components/schemas/bulkQuoteStatusResponse.yaml
+    '500':
+      description: An error occurred processing the bulk quote
+      content:
+        application/json:
+          schema:
+            $ref: ../components/schemas/errorResponse.yaml

package/OutboundServer/api_template/paths/bulkTransfers.yaml

@@ -0,0 +1,23 @@
+post:
+  summary: Sends money from one account to multiple accounts
+  description: >
+    The HTTP request `POST /bulkTransfers` is used to request the movement of
+    funds from payer DFSP to payees' DFSP.
+  tags:
+    - BulkTransfers
+  requestBody:
+    description: Bulk transfer request body
+    content:
+      application/json:
+        schema:
+          $ref: ../components/schemas/bulkTransferRequest.yaml
+    required: true
+  responses:
+    '200':
+      $ref: ../components/responses/bulkTransferSuccess.yaml
+    '400':
+      $ref: ../components/responses/bulkTransferBadRequest.yaml
+    '500':
+      $ref: ../components/responses/bulkTransferServerError.yaml
+    '504':
+      $ref: ../components/responses/bulkTransferTimeout.yaml

package/OutboundServer/api_template/paths/bulkTransfers_bulkTransferId.yaml

@@ -0,0 +1,24 @@
+get:
+  summary: Retrieves information for a specific bulk transfer
+  description: >-
+    The HTTP request `GET /bulkTransfers/{bulktTransferId}` is used to get
+    information regarding a bulk transfer created or requested earlier. The
+    `{bulkTransferId}` in the URI should contain the `bulkTransferId` that was
+    used for the creation of the bulk transfer.
+  tags:
+    - BulkTransfers
+  parameters:
+    - $ref: ../components/parameters/bulkTransferId.yaml
+  responses:
+    '200':
+      description: Bulk transfer information successfully retrieved
+      content:
+        application/json:
+          schema:
+            $ref: ../components/schemas/bulkTransferStatusResponse.yaml
+    '500':
+      description: An error occurred processing the bulk transfer
+      content:
+        application/json:
+          schema:
+            $ref: ../components/schemas/errorResponse.yaml

package/OutboundServer/api_template/paths/parties_Type_ID.yaml

@@ -0,0 +1,20 @@
+parameters:
+  - $ref: >-
+      ../../../node_modules/@mojaloop/api-snippets/fspiop/v1_1/openapi3/components/parameters/Type.yaml
+  - $ref: >-
+      ../../../node_modules/@mojaloop/api-snippets/fspiop/v1_1/openapi3/components/parameters/ID.yaml
+get:
+  description: >-
+    The HTTP request GET /parties// (or GET /parties///) is used to lookup
+    information regarding the requested Party, defined by ,  and optionally (for
+    example, GET /parties/MSISDN/123456789, or GET
+    /parties/BUSINESS/shoecompany/employee1).
+  summary: PartiesByTypeAndID
+  tags:
+    - parties
+  operationId: PartiesByTypeAndID
+  responses:
+    '200':
+      $ref: ../components/responses/partiesByIdSuccess.yaml
+    '404':
+      $ref: ../components/responses/partiesByIdError404.yaml

package/OutboundServer/api_template/paths/parties_Type_ID_SubId.yaml

@@ -0,0 +1,22 @@
+parameters:
+  - $ref: >-
+      ../../../node_modules/@mojaloop/api-snippets/fspiop/v1_1/openapi3/components/parameters/Type.yaml
+  - $ref: >-
+      ../../../node_modules/@mojaloop/api-snippets/fspiop/v1_1/openapi3/components/parameters/ID.yaml
+  - $ref: >-
+      ../../../node_modules/@mojaloop/api-snippets/fspiop/v1_1/openapi3/components/parameters/SubId.yaml
+get:
+  description: >-
+    The HTTP request GET /parties// (or GET /parties///) is used to lookup
+    information regarding the requested Party, defined by ,  and optionally (for
+    example, GET /parties/MSISDN/123456789, or GET
+    /parties/BUSINESS/shoecompany/employee1).
+  summary: PartiesSubIdByTypeAndID
+  tags:
+    - parties
+  operationId: PartiesSubIdByTypeAndID
+  responses:
+    '200':
+      $ref: ../components/responses/partiesByIdSuccess.yaml
+    '404':
+      $ref: ../components/responses/partiesByIdError404.yaml

package/OutboundServer/api_template/paths/quotes.yaml

@@ -0,0 +1,20 @@
+post:
+  summary: Quotes endpoint
+  description: >-
+    is used to request quotes from other DFSP
+  tags:
+    - quotes
+  operationId: QuotesPost
+  requestBody:
+    description: Quotes request payload
+    content:
+      application/json:
+        schema:
+          $ref: ../components/schemas/quotesPostRequest.yaml
+    required: true
+  responses:
+    '200':
+      $ref: ../components/responses/quotesPostSuccess.yaml
+    '500':
+      $ref: ../components/responses/quotesServerError.yaml
+  

package/OutboundServer/api_template/paths/requestToPay.yaml

@@ -0,0 +1,22 @@
+post:
+  summary: Receiver requesting funds from Sender
+  description: >
+    The HTTP request `POST /requestToPay` is used to support Pull Funds pattern
+    where in a receiver can request for funds from the Sender.
+
+    The underlying API has two stages:
+
+      1. Party lookup. This facilitates a check by the sending party that the destination party is correct before proceeding with a money movement.
+      2. Transaction Request. This request enables a Payee to request Payer to send electronic funds to the Payee.
+  tags:
+    - RequestToPay
+  requestBody:
+    description: RequestToPay request body
+    content:
+      application/json:
+        schema:
+          $ref: ../components/schemas/requestToPayRequest.yaml
+    required: true
+  responses:
+    '200':
+      $ref: ../components/responses/requestToPaySuccess.yaml

package/OutboundServer/api_template/paths/requestToPayTransfer.yaml

@@ -0,0 +1,57 @@
+post:
+  summary: >-
+    Used to trigger funds from customer fsp account to merchant fsp account.
+    This is a follow-up request to requestToPay.
+  description: >
+    The HTTP request `POST /requestToPayTransfer` is used to request the
+    movement of funds from payer DFSP to payee DFSP.
+
+    The underlying Mojaloop API has three stages for money transfer:
+
+      1. Quotation. This facilitates the exchange of fee information and the construction of a cryptographic "contract" between payee and payer DFSPs before funds are transferred.
+      2. Authorization. This facilitates getting OTP from payee DFSP.
+      3. Transfer. The enactment of the previously agreed "contract"
+
+    This method has several modes of operation.
+
+    - If the configuration variable `AUTO_ACCEPT_QUOTES` is set to `"false"`
+    this method will terminate and return the quotation when it has been
+    received from the payee DFSP.
+      If the payee wished to proceed with the otp, then a subsequent `PUT /transfers/{transferId}` request (accepting the quote) is required to continue the operation.
+      The scheme adapter will then proceed with the transfer state.
+
+    - If the configuration variable `AUTO_ACCEPT_OTP` is set to `"false"` this
+    method will terminate and return the otp when it has been received from the
+    payee DFSP.
+      If the payer wished to proceed with the transfer, then a subsequent `PUT /transfers/{transferId}` request (accepting the quote) is required to continue the operation.
+      The scheme adapter will then proceed with the transfer state.
+
+    If the configuration variables `AUTO_ACCEPT_PARTIES` and
+    `AUTO_ACCEPT_QUOTES` are both set to `"true"` this method will block until
+    all three transfer stages are complete. Upon completion it will return the
+    entire set of transfer details received during the operation.
+
+
+    Combinations of settings for `AUTO_ACCEPT...` configuration variables allow
+    the scheme adapter user to decide which mode of operation best suits their
+    use cases. i.e. the scheme adapter can be configured to "break" the three
+    stage transfer at these points in order to execute backend logic such as
+    party verification, quoted fees assessments etc...
+  tags:
+    - RequestToPayTransfer
+  requestBody:
+    description: Request To Pay Transfer request body
+    content:
+      application/json:
+        schema:
+          $ref: ../components/schemas/requestToPayTransferRequest.yaml
+    required: true
+  responses:
+    '200':
+      $ref: ../components/responses/requestToPayTransferSuccess.yaml
+    '400':
+      $ref: ../components/responses/requestToPayTransferBadRequest.yaml
+    '500':
+      $ref: ../components/responses/transferServerError.yaml
+    '504':
+      $ref: ../components/responses/transferTimeout.yaml

package/OutboundServer/api_template/paths/requestToPayTransfer_requestToPayTransactionId.yaml

@@ -0,0 +1,34 @@
+put:
+  summary: >-
+    Continues a transfer that has paused at the otp stage in order to accept or
+    reject quote
+  description: >
+    The HTTP request `PUT /transfers/{transferId}` is used to continue a
+    transfer initiated via the `POST /transfers` method that has halted after
+    party lookup and/or quotation stage.
+
+
+    The request body should contain either the "acceptOTP" or "acceptQuote"
+    property set to `true` as required to continue the transfer.
+
+
+    See the description of the `POST /requestToPayTransfer` HTTP method for more
+    information on modes of transfer.
+  tags:
+    - RequestToPayTransferID
+  requestBody:
+    content:
+      application/json:
+        schema:
+          oneOf:
+            - $ref: ../components/schemas/transferContinuationAcceptQuote.yaml
+            - $ref: ../components/schemas/transferContinuationAcceptOTP.yaml
+  parameters:
+    - $ref: ../components/parameters/requestToPayTransactionId.yaml
+  responses:
+    '200':
+      $ref: ../components/responses/transferSuccess.yaml
+    '500':
+      $ref: ../components/responses/transferServerError.yaml
+    '504':
+      $ref: ../components/responses/transferTimeout.yaml

package/OutboundServer/api_template/paths/simpleTransfers.yaml

@@ -0,0 +1,19 @@
+post:
+  summary: Simple Transfers endpoint
+  description: >-
+    is used to request a transfer
+  tags:
+    - transfers
+  operationId: SimpleTransfersPost
+  requestBody:
+    description: Simple Transfer request payload
+    content:
+      application/json:
+        schema:
+          $ref: ../components/schemas/simpleTransfersPostRequest.yaml
+    required: true
+  responses:
+    '200':
+      $ref: ../components/responses/simpleTransfersPostSuccess.yaml
+    '500':
+      $ref: ../components/responses/simpleTransfersServerError.yaml

package/OutboundServer/api_template/paths/transfers.yaml

@@ -0,0 +1,55 @@
+post:
+  summary: Sends money from one account to another
+  description: >
+    The HTTP request `POST /transfers` is used to request the movement of funds
+    from payer DFSP to payee DFSP.
+
+    The underlying Mojaloop API has three stages for money transfer:
+
+      1. Party lookup. This facilitates a check by the sending party that the destination party is correct before proceeding with a money movement.
+      2. Quotation. This facilitates the exchange of fee information and the construction of a cryptographic "contract" between payee and payer DFSPs before funds are transferred.
+      3. Transfer. The enactment of the previously agreed "contract"
+
+    This method has several modes of operation.
+
+    - If the configuration variables `AUTO_ACCEPT_PARTIES` is set to `"false"`
+    this method will terminate when the payee party has been resolved and return
+    the payee party details.
+      If the payee wishes to proceed with the transfer, then a subsequent `PUT /transfers/{transferId}` request (accepting the payee party) is required to continue the operation.
+      The scheme adapter will then proceed with quotation stage...
+
+    - If the configuration variable `AUTO_ACCEPT_QUOTES` is set to `"false"`
+    this method will terminate and return the quotation when it has been
+    received from the payee DFSP.
+      If the payee wished to proceed with the transfer, then a subsequent `PUT /transfers/{transferId}` request (accepting the quote) is required to continue the operation.
+      The scheme adapter will then proceed with the transfer state.
+
+    If the configuration variables `AUTO_ACCEPT_PARTIES` and
+    `AUTO_ACCEPT_QUOTES` are both set to `"true"` this method will block until
+    all three transfer stages are complete. Upon completion it will return the
+    entire set of transfer details received during the operation.
+
+
+    Combinations of settings for `AUTO_ACCEPT...` configuration variables allow
+    the scheme adapter user to decide which mode of operation best suits their
+    use cases. i.e. the scheme adapter can be configured to "break" the three
+    stage transfer at these points in order to execute backend logic such as
+    party verification, quoted fees assessments etc...
+  tags:
+    - Transfers
+  requestBody:
+    description: Transfer request body
+    content:
+      application/json:
+        schema:
+          $ref: ../components/schemas/transferRequest.yaml
+    required: true
+  responses:
+    '200':
+      $ref: ../components/responses/transferSuccess.yaml
+    '400':
+      $ref: ../components/responses/transferBadRequest.yaml
+    '500':
+      $ref: ../components/responses/transferServerError.yaml
+    '504':
+      $ref: ../components/responses/transferTimeout.yaml

package/OutboundServer/api_template/paths/transfers_transferId.yaml

@@ -0,0 +1,58 @@
+put:
+  summary: >-
+    Continues a transfer that has paused at the quote stage in order to accept
+    or reject payee party and/or quote
+  description: >
+    The HTTP request `PUT /transfers/{transferId}` is used to continue a
+    transfer initiated via the `POST /transfers` method that has halted after
+    party lookup and/or quotation stage.
+
+
+    The request body should contain either the "acceptParty" or "acceptQuote"
+    property set to `true` as required to continue the transfer.
+
+
+    See the description of the `POST /transfers` HTTP method for more
+    information on modes of transfer.
+  tags:
+    - Transfers
+  requestBody:
+    content:
+      application/json:
+        schema:
+          oneOf:
+            - $ref: ../components/schemas/transferContinuationAcceptParty.yaml
+            - $ref: ../components/schemas/transferContinuationAcceptQuote.yaml
+  parameters:
+    - $ref: ../components/parameters/transferId.yaml
+  responses:
+    '200':
+      $ref: ../components/responses/transferSuccess.yaml
+    '500':
+      $ref: ../components/responses/transferServerError.yaml
+    '504':
+      $ref: ../components/responses/transferTimeout.yaml
+get:
+  summary: Retrieves information for a specific transfer
+  description: >-
+    The HTTP request `GET /transfers/{transferId}` is used to get information
+    regarding a transfer created or requested earlier. The `{transferId}` in the
+    URI should contain the `transferId` that was used for the creation of the
+    transfer.
+  tags:
+    - Transfers
+  parameters:
+    - $ref: ../components/parameters/transferId.yaml
+  responses:
+    '200':
+      description: Transfer information successfully retrieved
+      content:
+        application/json:
+          schema:
+            $ref: ../components/schemas/transferStatusResponse.yaml
+    '500':
+      description: An error occurred processing the transfer
+      content:
+        application/json:
+          schema:
+            $ref: ../components/schemas/errorResponse.yaml

package/OutboundServer/handlers.js

@@ -0,0 +1,622 @@
+/**************************************************************************
+ *  (C) Copyright ModusBox Inc. 2019 - All rights reserved.               *
+ *                                                                        *
+ *  This file is made available under the terms of the license agreement  *
+ *  specified in the corresponding source code repository.                *
+ *                                                                        *
+ *  ORIGINAL AUTHOR:                                                      *
+ *       James Bush - james.bush@modusbox.com                             *
+ *  CONTRIBUTORS:                                                         *
+ *       Steven Oderayi - steven.oderayi@modusbox.com                     *
+ **************************************************************************/
+
+'use strict';
+
+
+const util = require('util');
+const {
+    AccountsModel,
+    OutboundTransfersModel,
+    OutboundBulkTransfersModel,
+    OutboundRequestToPayTransferModel,
+    OutboundRequestToPayModel,
+    OutboundBulkQuotesModel,
+    PartiesModel,
+    QuotesModel,
+    TransfersModel,
+    AuthorizationsModel
+} = require('../lib/model');
+
+
+/**
+ * Error handling logic shared by outbound API handlers
+ */
+const handleError = (method, err, ctx, stateField) => {
+    ctx.state.logger.log(`Error handling ${method}: ${util.inspect(err)}`);
+    ctx.response.status = err.httpStatusCode || 500;
+    ctx.response.body = {
+        message: err.message || 'Unspecified error',
+        [stateField]: err[stateField] || {},
+        statusCode: (err.httpStatusCode || 500).toString()
+    };
+    if(err[stateField]
+        && err[stateField].lastError
+        && err[stateField].lastError.mojaloopError
+        && err[stateField].lastError.mojaloopError.errorInformation
+        && err[stateField].lastError.mojaloopError.errorInformation.errorCode) {
+
+        // by default we set the statusCode property of the error body to be that of any model state lastError
+        // property containing a mojaloop API error structure. This means the caller does not have to inspect
+        // the structure of the response object in depth to ascertain an underlying mojaloop API error code.
+        const errorInformation = err[stateField].lastError.mojaloopError.errorInformation;
+        ctx.response.body.statusCode = errorInformation.errorCode;
+
+        // if we have been configured to use an error extensionList item as status code, look for it and use
+        // it if it is present...
+        if(ctx.state.conf.outboundErrorStatusCodeExtensionKey
+            && errorInformation.extensionList
+            && Array.isArray(errorInformation.extensionList.extension)) {
+
+            // search the extensionList array for a key that matches what we have been configured to look for...
+            // the first one will do - spec is a bit loose on duplicate keys...
+            const extensionItem = errorInformation.extensionList.extension.find(e => {
+                return e.key === ctx.state.conf.outboundErrorStatusCodeExtensionKey;
+            });
+
+            if(extensionItem) {
+                ctx.response.body.statusCode = extensionItem.value;
+            }
+        }
+    }
+};
+
+const handleTransferError = (method, err, ctx) =>
+    handleError(method, err, ctx, 'transferState');
+
+const handleBulkTransferError = (method, err, ctx) =>
+    handleError(method, err, ctx, 'bulkTransferState');
+
+const handleBulkQuoteError = (method, err, ctx) =>
+    handleError(method, err, ctx, 'bulkQuoteState');
+
+const handleAccountsError = (method, err, ctx) =>
+    handleError(method, err, ctx, 'executionState');
+
+const handleRequestToPayError = (method, err, ctx) =>
+    handleError(method, err, ctx, 'requestToPayState');
+
+const handleRequestToPayTransferError = (method, err, ctx) =>
+    handleError(method, err, ctx, 'requestToPayTransferState');
+
+const handleRequestPartiesInformationError = (method, err, ctx) =>
+    handleError(method, err, ctx, 'requestPartiesInformationState');
+
+const handleRequestQuotesInformationError = (method, err, ctx) =>
+    handleError(method, err, ctx, 'requestQuotesInformationState');
+
+const handleRequestSimpleTransfersInformationError = (method, err, ctx) =>
+    handleError(method, err, ctx, 'requestSimpleTransfersInformationState');
+
+const handleRequestAuthorizationsInformationError = (method, err, ctx) =>
+    handleError(method, err, ctx, 'requestAuthorizationsInformationState');
+
+/**
+ * Handler for outbound transfer request initiation
+ */
+const postTransfers = async (ctx) => {
+    try {
+        // this requires a multi-stage sequence with the switch.
+        let transferRequest = {
+            ...ctx.request.body
+        };
+
+        // use the transfers model to execute asynchronous stages with the switch
+        const model = new OutboundTransfersModel({
+            ...ctx.state.conf,
+            cache: ctx.state.cache,
+            logger: ctx.state.logger,
+            wso2: ctx.state.wso2,
+        });
+
+        // initialize the transfer model and start it running
+        await model.initialize(transferRequest);
+        const response = await model.run();
+
+        // return the result
+        ctx.response.status = 200;
+        ctx.response.body = response;
+    }
+    catch(err) {
+        return handleTransferError('postTransfers', err, ctx);
+    }
+};
+
+/**
+ * Handler for outbound transfer request
+ */
+const getTransfers = async (ctx) => {
+    try {
+        let transferRequest = {
+            ...ctx.request.body,
+            transferId: ctx.state.path.params.transferId,
+            currentState: 'getTransfer',
+        };
+
+        // use the transfers model to execute asynchronous stages with the switch
+        const model = new OutboundTransfersModel({
+            ...ctx.state.conf,
+            cache: ctx.state.cache,
+            logger: ctx.state.logger,
+            wso2: ctx.state.wso2,
+        });
+
+        // initialize the transfer model and start it running
+        await model.initialize(transferRequest);
+        const response = await model.run();
+
+        // return the result
+        ctx.response.status = 200;
+        ctx.response.body = response;
+    }
+    catch(err) {
+        return handleTransferError('getTransfers', err, ctx);
+    }
+};
+
+/**
+ * Handler for resuming outbound transfers in scenarios where two-step transfers are enabled
+ * by disabling the autoAcceptQuote SDK option
+ */
+const putTransfers = async (ctx) => {
+    try {
+        // this requires a multi-stage sequence with the switch.
+        // use the transfers model to execute asynchronous stages with the switch
+        const model = new OutboundTransfersModel({
+            ...ctx.state.conf,
+            cache: ctx.state.cache,
+            logger: ctx.state.logger,
+            wso2: ctx.state.wso2,
+        });
+
+        // TODO: check the incoming body to reject party or quote when requested to do so
+
+        // load the transfer model from cache and start it running again
+        await model.load(ctx.state.path.params.transferId);
+
+        const response = await model.run();
+
+        // return the result
+        ctx.response.status = 200;
+        ctx.response.body = response;
+    }
+    catch(err) {
+        return handleTransferError('putTransfers', err, ctx);
+    }
+};
+
+/**
+ * Handler for outbound bulk transfer request
+ */
+const postBulkTransfers = async (ctx) => {
+    try {
+        // this requires a multi-stage sequence with the switch.
+        let bulkTransferRequest = {
+            ...ctx.request.body
+        };
+
+        // use the bulk transfers model to execute asynchronous stages with the switch
+        const model = new OutboundBulkTransfersModel({
+            ...ctx.state.conf,
+            cache: ctx.state.cache,
+            logger: ctx.state.logger,
+            wso2: ctx.state.wso2,
+        });
+
+        await model.initialize(bulkTransferRequest);
+        const response = await model.run();
+
+        // return the result
+        ctx.response.status = 200;
+        ctx.response.body = response;
+    }
+    catch (err) {
+        return handleBulkTransferError('postBulkTransfers', err, ctx);
+    }
+};
+
+/**
+ * Handler for outbound bulk transfer request
+ */
+const getBulkTransfers = async (ctx) => {
+    try {
+        const bulkTransferRequest = {
+            ...ctx.request.body,
+            bulkTransferId: ctx.state.path.params.bulkTransferId,
+            currentState: 'getBulkTransfer',
+        };
+
+        // use the bulk transfers model to execute asynchronous stages with the switch
+        const model = new OutboundBulkTransfersModel({
+            ...ctx.state.conf,
+            cache: ctx.state.cache,
+            logger: ctx.state.logger,
+            wso2: ctx.state.wso2,
+        });
+
+        await model.initialize(bulkTransferRequest);
+        const response = await model.getBulkTransfer();
+
+        // return the result
+        ctx.response.status = 200;
+        ctx.response.body = response;
+    }
+    catch (err) {
+        return handleBulkTransferError('getBulkTransfers', err, ctx);
+    }
+};
+
+/**
+ * Handler for outbound bulk quote request
+ */
+const postBulkQuotes = async (ctx) => {
+    try {
+        let bulkQuoteRequest = {
+            ...ctx.request.body
+        };
+
+        // use the bulk quotes model to execute asynchronous request with the switch
+        const model = new OutboundBulkQuotesModel({
+            ...ctx.state.conf,
+            cache: ctx.state.cache,
+            logger: ctx.state.logger,
+            wso2: ctx.state.wso2,
+        });
+
+        await model.initialize(bulkQuoteRequest);
+        const response = await model.run();
+
+        // return the result
+        ctx.response.status = 200;
+        ctx.response.body = response;
+    }
+    catch (err) {
+        return handleBulkQuoteError('postBulkQuotes', err, ctx);
+    }
+};
+
+/**
+ * Handler for outbound bulk quote request
+ */
+const getBulkQuoteById = async (ctx) => {
+    try {
+        const bulkQuoteRequest = {
+            ...ctx.request.body,
+            bulkQuoteId: ctx.state.path.params.bulkQuoteId,
+            currentState: 'getBulkQuote',
+        };
+
+        // use the bulk quotes model to execute asynchronous stages with the switch
+        const model = new OutboundBulkQuotesModel({
+            ...ctx.state.conf,
+            cache: ctx.state.cache,
+            logger: ctx.state.logger,
+            wso2: ctx.state.wso2,
+        });
+
+        await model.initialize(bulkQuoteRequest);
+        const response = await model.getBulkQuote();
+
+        // return the result
+        ctx.response.status = 200;
+        ctx.response.body = response;
+    }
+    catch (err) {
+        return handleBulkQuoteError('getBulkQuoteById', err, ctx);
+    }
+};
+
+/**
+ * Handler for outbound transfer request initiation
+ */
+const postRequestToPayTransfer = async (ctx) => {
+    try {
+        // this requires a multi-stage sequence with the switch.
+        let requestToPayTransferRequest = {
+            ...ctx.request.body
+        };
+
+        // use the merchant transfers model to execute asynchronous stages with the switch
+        const model = new OutboundRequestToPayTransferModel({
+            ...ctx.state.conf,
+            cache: ctx.state.cache,
+            logger: ctx.state.logger,
+            wso2: ctx.state.wso2,
+        });
+
+        // initialize the transfer model and start it running
+        await model.initialize(requestToPayTransferRequest);
+        const response = await model.run();
+        // return the result
+        ctx.response.status = 200;
+        ctx.response.body = response;
+    }
+    catch (err) {
+        return handleRequestToPayTransferError('postRequestToPayTransfer', err, ctx);
+    }
+};
+
+/**
+ * Handler for resuming outbound transfers in scenarios where two-step transfers are enabled
+ * by disabling the autoAcceptQuote SDK option
+ */
+const putRequestToPayTransfer = async (ctx) => {
+    try {
+        // this requires a multi-stage sequence with the switch.
+        // use the transfers model to execute asynchronous stages with the switch
+        const model = new OutboundRequestToPayTransferModel({
+            ...ctx.state.conf,
+            cache: ctx.state.cache,
+            logger: ctx.state.logger,
+            wso2: ctx.state.wso2,
+        });
+
+        // TODO: check the incoming body to reject party or quote when requested to do so
+        const data = ctx.request.body;
+        // load the transfer model from cache and start it running again
+        await model.load(ctx.state.path.params.requestToPayTransactionId);
+        let response;
+        if(data.acceptQuote === true || data.acceptOTP === true) {
+            response = await model.run();
+        } else {
+            response = await model.rejectRequestToPay();
+        }
+
+        // return the result
+        ctx.response.status = 200;
+        ctx.response.body = response;
+    }
+    catch(err) {
+        return handleTransferError('putRequestToPayTransfer', err, ctx);
+    }
+};
+
+
+/**
+ * Handler for outbound participants request initiation
+ */
+const postAccounts = async (ctx) => {
+    try {
+        const model = new AccountsModel({
+            ...ctx.state.conf,
+            cache: ctx.state.cache,
+            logger: ctx.state.logger,
+            wso2: ctx.state.wso2,
+        });
+
+        const state = {
+            accounts: ctx.request.body,
+        };
+
+        // initialize the accounts model and run it
+        await model.initialize(state);
+        const response = await model.run();
+
+        // return the result
+        ctx.response.status = 200;
+        ctx.response.body = response;
+    }
+    catch(err) {
+        return handleAccountsError('postAccounts', err, ctx);
+    }
+};
+
+const postRequestToPay = async (ctx) => {
+    try {
+        // this requires a multi-stage sequence with the switch.
+        let requestToPayInboundRequest = {
+            ...ctx.request.body
+        };
+
+        // use the transfers model to execute asynchronous stages with the switch
+        const model = new OutboundRequestToPayModel({
+            ...ctx.state.conf,
+            cache: ctx.state.cache,
+            logger: ctx.state.logger,
+            wso2: ctx.state.wso2,
+        });
+
+        // initialize the transfer model and start it running
+        await model.initialize(requestToPayInboundRequest);
+        const response = await model.run();
+
+        // return the result
+        ctx.response.status = 200;
+        ctx.response.body = response;
+
+    } catch(err) {
+        return handleRequestToPayError('requestToPayInboundRequest', err, ctx);
+    }
+};
+
+const healthCheck = async (ctx) => {
+    ctx.response.status = 200;
+    ctx.response.body = '';
+};
+
+const getPartiesByTypeAndId = async (ctx) => {
+    const type = ctx.state.path.params.Type;
+    const id = ctx.state.path.params.ID;
+    const subId = ctx.state.path.params.SubId;
+
+    const args = { type, id, subId };
+
+    try {
+        // prepare config
+        const modelConfig = {
+            ...ctx.state.conf,
+            cache: ctx.state.cache,
+            logger: ctx.state.logger,
+            wso2Auth: ctx.state.wso2Auth,
+        };
+
+        const cacheKey = PartiesModel.generateKey(args);
+
+        // use the parties model to execute asynchronous stages with the switch
+        const model = await PartiesModel.create({}, cacheKey, modelConfig);
+
+        // run model's workflow
+        const response = await model.run(args);
+
+        // return the result
+        if (response.errorInformation) {
+            ctx.response.status = 404;
+        } else {
+            ctx.response.status = 200;
+        }
+        ctx.response.body = response;
+    } catch (err) {
+        return handleRequestPartiesInformationError('getPartiesByTypeAndId', err, ctx);
+    }
+};
+
+const postQuotes = async (ctx) => {
+    const quote = { ...ctx.request.body.quotesPostRequest };
+    const fspId = ctx.request.body.fspId;
+    const args = { quoteId: quote.quoteId, fspId, quote };
+
+    try {
+        // prepare config
+        const modelConfig = {
+            ...ctx.state.conf,
+            cache: ctx.state.cache,
+            logger: ctx.state.logger,
+            wso2Auth: ctx.state.wso2Auth,
+        };
+
+        const cacheKey = QuotesModel.generateKey(args);
+
+        // use the parties model to execute asynchronous stages with the switch
+        const model = await QuotesModel.create({}, cacheKey, modelConfig);
+
+        // run model's workflow
+        const response = await model.run(args);
+
+        // return the result
+        ctx.response.status = 200;
+        ctx.response.body = response;
+    } catch (err) {
+        return handleRequestQuotesInformationError('postQuotes', err, ctx);
+    }
+};
+
+const postSimpleTransfers = async (ctx) => {
+    const transfer = { ...ctx.request.body.transfersPostRequest };
+    const fspId = ctx.request.body.fspId;
+    const args = { transferId: transfer.transferId, fspId, transfer };
+
+    try {
+        // prepare config
+        const modelConfig = {
+            ...ctx.state.conf,
+            cache: ctx.state.cache,
+            logger: ctx.state.logger,
+            wso2Auth: ctx.state.wso2Auth,
+        };
+
+        const cacheKey = TransfersModel.generateKey(args);
+
+        // use the parties model to execute asynchronous stages with the switch
+        const model = await TransfersModel.create({}, cacheKey, modelConfig);
+
+        // run model's workflow
+        const response = await model.run(args);
+        // return the result
+        ctx.response.status = 200;
+        ctx.response.body = response;
+    } catch (err) {
+        return handleRequestSimpleTransfersInformationError('postSimpleTransfers', err, ctx);
+    }
+};
+
+const postAuthorizations = async (ctx) => {
+
+    const authorization = { ...ctx.request.body.authorizationsPostRequest };
+    const fspId = ctx.request.body.fspId;
+    const args = { transactionRequestId: authorization.transactionRequestId, fspId, authorization };
+
+    try {
+        // prepare config
+        const modelConfig = {
+            ...ctx.state.conf,
+            cache: ctx.state.cache,
+            logger: ctx.state.logger,
+            wso2Auth: ctx.state.wso2Auth,
+        };
+
+        const cacheKey = AuthorizationsModel.generateKey(args);
+
+        // use the authorizations model to execute asynchronous stages with the switch
+        const model = await AuthorizationsModel.create({}, cacheKey, modelConfig);
+
+        // run model's workflow
+        const response = await model.run(args);
+
+        // return the result
+        ctx.response.status = 200;
+        ctx.response.body = response;
+    } catch (err) {
+        return handleRequestAuthorizationsInformationError('postAuthorizations', err, ctx);
+    }
+};
+
+module.exports = {
+    '/': {
+        get: healthCheck
+    },
+    '/transfers': {
+        post: postTransfers
+    },
+    '/transfers/{transferId}': {
+        get: getTransfers,
+        put: putTransfers
+    },
+    '/bulkTransfers': {
+        post: postBulkTransfers
+    },
+    '/bulkTransfers/{bulkTransferId}': {
+        get: getBulkTransfers,
+    },
+    '/bulkQuotes': {
+        post: postBulkQuotes,
+    },
+    '/bulkQuotes/{bulkQuoteId}': {
+        get: getBulkQuoteById,
+    },
+    '/accounts': {
+        post: postAccounts
+    },
+    '/requestToPay': {
+        post: postRequestToPay
+    },
+    '/requestToPayTransfer': {
+        post: postRequestToPayTransfer
+    },
+    '/requestToPayTransfer/{requestToPayTransactionId}': {
+        put: putRequestToPayTransfer
+    },
+    '/parties/{Type}/{ID}': {
+        get: getPartiesByTypeAndId
+    },
+    '/parties/{Type}/{ID}/{SubId}': {
+        get: getPartiesByTypeAndId
+    },
+    '/quotes': {
+        post: postQuotes
+    },
+    '/simpleTransfers': {
+        post: postSimpleTransfers
+    },
+    '/authorizations': {
+        post: postAuthorizations
+    }    
+};