feat: payment method handler service (quoting)

packages/backend/src/app.ts

@@ -84,6 +84,8 @@ import { AutoPeeringService } from './payment-method/ilp/auto-peering/service'
 import { AutoPeeringRoutes } from './payment-method/ilp/auto-peering/routes'
 import { Rafiki as ConnectorApp } from './payment-method/ilp/connector/core'
 import { AxiosInstance } from 'axios'
+import { PaymentMethodHandlerService } from './payment-method/handler/service'
+import { IlpPaymentService } from './payment-method/ilp/service'
 
 export interface AppContextData {
   logger: Logger
@@ -225,6 +227,8 @@ export interface AppServices {
   autoPeeringRoutes: Promise<AutoPeeringRoutes>
   connectorApp: Promise<ConnectorApp>
   tigerbeetle: Promise<TigerbeetleClient>
+  paymentMethodHandlerService: Promise<PaymentMethodHandlerService>
+  ilpPaymentService: Promise<IlpPaymentService>
 }
 
 export type AppContainer = IocContract<AppServices>

packages/backend/src/index.ts

@@ -47,6 +47,8 @@ import { createFeeService } from './fee/service'
 import { createAutoPeeringService } from './payment-method/ilp/auto-peering/service'
 import { createAutoPeeringRoutes } from './payment-method/ilp/auto-peering/routes'
 import axios from 'axios'
+import { createIlpPaymentService } from './payment-method/ilp/service'
+import { createPaymentMethodHandlerService } from './payment-method/handler/service'
 
 BigInt.prototype.toJSON = function () {
   return this.toString()
@@ -432,6 +434,24 @@ export function initIocContainer(
     })
   })
 
+  container.singleton('ilpPaymentService', async (deps) => {
+    return createIlpPaymentService({
+      logger: await deps.use('logger'),
+      knex: await deps.use('knex'),
+      config: await deps.use('config'),
+      makeIlpPlugin: await deps.use('makeIlpPlugin'),
+      ratesService: await deps.use('ratesService')
+    })
+  })
+
+  container.singleton('paymentMethodHandlerService', async (deps) => {
+    return createPaymentMethodHandlerService({
+      logger: await deps.use('logger'),
+      knex: await deps.use('knex'),
+      ilpPaymentService: await deps.use('ilpPaymentService')
+    })
+  })
+
   return container
 }
 

packages/backend/src/payment-method/handler/service.test.ts

@@ -0,0 +1,93 @@
+import {
+  PaymentMethod,
+  PaymentMethodHandlerService,
+  StartQuoteOptions
+} from './service'
+import { initIocContainer } from '../../'
+import { createTestApp, TestContainer } from '../../tests/app'
+import { Config } from '../../config/app'
+import { IocContract } from '@adonisjs/fold'
+import { AppServices } from '../../app'
+import { createAsset } from '../../tests/asset'
+import { createPaymentPointer } from '../../tests/paymentPointer'
+
+import { createReceiver } from '../../tests/receiver'
+import { IlpPaymentService } from '../ilp/service'
+import { truncateTables } from '../../tests/tableManager'
+
+describe('PaymentMethodHandlerService', (): void => {
+  let deps: IocContract<AppServices>
+  let appContainer: TestContainer
+  let paymentMethodHandlerService: PaymentMethodHandlerService
+  let ilpPaymentService: IlpPaymentService
+
+  beforeAll(async (): Promise<void> => {
+    deps = initIocContainer(Config)
+    appContainer = await createTestApp(deps)
+
+    paymentMethodHandlerService = await deps.use('paymentMethodHandlerService')
+    ilpPaymentService = await deps.use('ilpPaymentService')
+  })
+
+  afterEach(async (): Promise<void> => {
+    jest.restoreAllMocks()
+    await truncateTables(appContainer.knex)
+  })
+
+  afterAll(async (): Promise<void> => {
+    await appContainer.shutdown()
+  })
+
+  describe('getQuote', (): void => {
+    test('calls ilpPaymentService for ILP payment type', async (): Promise<void> => {
+      const asset = await createAsset(deps)
+      const paymentPointer = await createPaymentPointer(deps, {
+        assetId: asset.id
+      })
+
+      const options: StartQuoteOptions = {
+        paymentPointer,
+        receiver: await createReceiver(deps, paymentPointer),
+        debitAmount: {
+          assetCode: 'USD',
+          assetScale: 2,
+          value: 100n
+        }
+      }
+
+      const ilpPaymentServiceGetQuoteSpy = jest.spyOn(
+        ilpPaymentService,
+        'getQuote'
+      )
+
+      await paymentMethodHandlerService.getQuote('ILP', options)
+
+      expect(ilpPaymentServiceGetQuoteSpy).toHaveBeenCalledWith(options)
+    })
+
+    test('throws if invalid payment method', async (): Promise<void> => {
+      const asset = await createAsset(deps, {
+        code: 'USD',
+        scale: 2
+      })
+
+      const paymentPointer = await createPaymentPointer(deps, {
+        assetId: asset.id
+      })
+
+      const options: StartQuoteOptions = {
+        paymentPointer,
+        receiver: await createReceiver(deps, paymentPointer),
+        debitAmount: {
+          assetCode: 'USD',
+          assetScale: 2,
+          value: 100n
+        }
+      }
+
+      expect(() =>
+        paymentMethodHandlerService.getQuote('' as PaymentMethod, options)
+      ).toThrow('Payment method not supported')
+    })
+  })
+})

packages/backend/src/payment-method/handler/service.ts

@@ -0,0 +1,68 @@
+import { Amount } from '../../open_payments/amount'
+import { PaymentPointer } from '../../open_payments/payment_pointer/model'
+import { Receiver } from '../../open_payments/receiver/model'
+import { BaseService } from '../../shared/baseService'
+import { IlpPaymentService } from '../ilp/service'
+
+export interface StartQuoteOptions {
+  paymentPointer: PaymentPointer
+  debitAmount?: Amount
+  receiveAmount?: Amount
+  receiver: Receiver
+}
+
+export interface PaymentQuote {
+  paymentPointer: PaymentPointer
+  receiver: Receiver
+  debitAmount: Amount
+  receiveAmount: Amount
+  additionalFields: Record<string, unknown>
+}
+
+export interface PaymentMethodService {
+  getQuote(quoteOptions: StartQuoteOptions): Promise<PaymentQuote>
+}
+
+export type PaymentMethod = 'ILP'
+
+export interface PaymentMethodHandlerService {
+  getQuote(
+    method: PaymentMethod,
+    quoteOptions: StartQuoteOptions
+  ): Promise<PaymentQuote>
+}
+
+interface ServiceDependencies extends BaseService {
+  ilpPaymentService: IlpPaymentService
+}
+
+export async function createPaymentMethodHandlerService({
+  logger,
+  knex,
+  ilpPaymentService
+}: ServiceDependencies): Promise<PaymentMethodHandlerService> {
+  const log = logger.child({
+    service: 'PaymentMethodHandlerService'
+  })
+  const deps: ServiceDependencies = {
+    logger: log,
+    knex,
+    ilpPaymentService
+  }
+
+  return {
+    getQuote: (method, quoteOptions) =>
+      getPaymentMethodService(deps, method).getQuote(quoteOptions)
+  }
+}
+
+function getPaymentMethodService(
+  deps: ServiceDependencies,
+  method: PaymentMethod
+): PaymentMethodService {
+  if (method === 'ILP') {
+    return deps.ilpPaymentService
+  }
+
+  throw new Error('Payment method not supported')
+}