feat(backend): add local payment

packages/backend/src/payment-method/ilp/connector/core/factories/rafiki-services.ts

@@ -49,7 +49,10 @@ export const RafikiServicesFactory = Factory.define<MockRafikiServices>(
       await accounting._getByIncomingToken(token)
   }))
   .attr('rates', {
-    convert: async (opts) => opts.sourceAmount,
+    convert: async (opts) => ({
+      amount: opts.sourceAmount,
+      scaledExchangeRate: 1
+    }),
     rates: () => {
       throw new Error('unimplemented')
     }

packages/backend/src/payment-method/ilp/connector/core/middleware/balance.ts

@@ -6,6 +6,7 @@ import {
 } from '../../../../../accounting/errors'
 import { Transaction, TransferType } from '../../../../../accounting/service'
 import { Config as AppConfig } from '../../../../../config/app'
+import { isConvertError } from '../../../../../rates/service'
 const { CannotReceiveError, InsufficientLiquidityError } = Errors
 
 export function createBalanceMiddleware(): ILPMiddleware {
@@ -40,8 +41,7 @@ export function createBalanceMiddleware(): ILPMiddleware {
       sourceAsset: accounts.incoming.asset,
       destinationAsset: accounts.outgoing.asset
     })
-    if (typeof destinationAmountOrError !== 'bigint') {
-      // ConvertError
+    if (isConvertError(destinationAmountOrError)) {
       logger.error(
         {
           amount,
@@ -55,8 +55,9 @@ export function createBalanceMiddleware(): ILPMiddleware {
         `Exchange rate error: ${destinationAmountOrError}`
       )
     }
+    const { amount: destinationAmount } = destinationAmountOrError
 
-    request.prepare.amount = destinationAmountOrError.toString()
+    request.prepare.amount = destinationAmount.toString()
 
     if (state.unfulfillable) {
       await next()
@@ -71,7 +72,7 @@ export function createBalanceMiddleware(): ILPMiddleware {
         sourceAccount: accounts.incoming,
         destinationAccount: accounts.outgoing,
         sourceAmount,
-        destinationAmount: destinationAmountOrError,
+        destinationAmount,
         transferType: TransferType.TRANSFER,
         timeout: AppConfig.tigerBeetleTwoPhaseTimeout
       }

packages/backend/src/payment-method/ilp/connector/core/test/middleware/balance-middleware.test.ts

@@ -75,7 +75,10 @@ describe('Balance Middleware', function () {
     const destinationAmount = BigInt(200)
     jest
       .spyOn(rates, 'convert')
-      .mockImplementationOnce(async () => destinationAmount)
+      .mockImplementationOnce(async () => ({
+        amount: destinationAmount,
+        scaledExchangeRate: 1
+      }))
 
     await expect(middleware(ctx, next)).resolves.toBeUndefined()
 

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

@@ -202,7 +202,9 @@ describe('LocalPaymentService', (): void => {
       const ratesService = await deps.use('ratesService')
       jest
         .spyOn(ratesService, 'convert')
-        .mockImplementation(() => Promise.resolve(100n))
+        .mockImplementation(() =>
+          Promise.resolve({ amount: 100n, scaledExchangeRate: 1 })
+        )
       expect.assertions(4)
       try {
         await localPaymentService.getQuote({
@@ -257,7 +259,7 @@ describe('LocalPaymentService', (): void => {
           incomingAssetCode | incomingAmountValue | debitAssetCode | expectedDebitAmount | exchangeRate | description
           ${'USD'}          | ${100n}             | ${'USD'}       | ${100n}             | ${null}      | ${'local currency'}
           ${'EUR'}          | ${100n}             | ${'USD'}       | ${100n}             | ${1.0}       | ${'cross currency, same rate'}
-          ${'EUR'}          | ${100n}             | ${'USD'}       | ${111n}             | ${0.9}       | ${'cross currency, exchange rate < 1'}
+          ${'EUR'}          | ${100n}             | ${'USD'}       | ${112n}             | ${0.9}       | ${'cross currency, exchange rate < 1'}
           ${'EUR'}          | ${100n}             | ${'USD'}       | ${50n}              | ${2.0}       | ${'cross currency, exchange rate > 1'}
         `(
           '$description',
@@ -272,7 +274,7 @@ describe('LocalPaymentService', (): void => {
 
             if (incomingAssetCode !== debitAssetCode) {
               ratesScope = mockRatesApi(exchangeRatesUrl, () => ({
-                [debitAssetCode]: 1 / exchangeRate
+                [incomingAssetCode]: exchangeRate
               }))
             }
 

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

@@ -30,6 +30,7 @@ import {
 } from '../../accounting/errors'
 import { IncomingPaymentService } from '../../open_payments/payment/incoming/service'
 import { IncomingPaymentState } from '../../open_payments/payment/incoming/model'
+import { ConvertResults } from '../../rates/util'
 
 export interface LocalPaymentService extends PaymentMethodService {}
 
@@ -58,18 +59,21 @@ async function getQuote(
   deps: ServiceDependencies,
   options: StartQuoteOptions
 ): Promise<PaymentQuote> {
-  const { receiver, debitAmount, receiveAmount } = options
+  const { receiver, debitAmount, receiveAmount, walletAddress } = options
 
   let debitAmountValue: bigint
   let receiveAmountValue: bigint
+  let exchangeRate: number
 
-  const convert = async (opts: RateConvertOpts) => {
-    let converted: bigint | ConvertError
+  const convert = async (
+    opts: RateConvertOpts
+  ): Promise<ConvertResults | ConvertError> => {
+    let convertResults: ConvertResults | ConvertError
     try {
-      converted = await deps.ratesService.convert(opts)
+      convertResults = await deps.ratesService.convert(opts)
     } catch (err) {
       deps.logger.error(
-        { receiver, debitAmount, receiveAmount, err },
+        { opts, err },
         'Unknown error while attempting to convert rates'
       )
       throw new PaymentMethodHandlerError(
@@ -80,23 +84,23 @@ async function getQuote(
         }
       )
     }
-    return converted
+    return convertResults
   }
 
   if (debitAmount) {
     debitAmountValue = debitAmount.value
-    const converted = await convert({
+    const convertResults = await convert({
       sourceAmount: debitAmountValue,
       sourceAsset: {
-        code: debitAmount.assetCode,
-        scale: debitAmount.assetScale
+        code: walletAddress.asset.code,
+        scale: walletAddress.asset.scale
       },
       destinationAsset: {
         code: receiver.assetCode,
         scale: receiver.assetScale
       }
     })
-    if (isConvertError(converted)) {
+    if (isConvertError(convertResults)) {
       throw new PaymentMethodHandlerError(
         'Received error during local quoting',
         {
@@ -105,21 +109,23 @@ async function getQuote(
         }
       )
     }
-    receiveAmountValue = converted
+    receiveAmountValue = convertResults.amount
+    exchangeRate = convertResults.scaledExchangeRate
   } else if (receiveAmount) {
     receiveAmountValue = receiveAmount.value
-    const converted = await convert({
+    const convertResults = await convert({
+      reverseDirection: true,
       sourceAmount: receiveAmountValue,
       sourceAsset: {
-        code: receiveAmount.assetCode,
-        scale: receiveAmount.assetScale
+        code: walletAddress.asset.code,
+        scale: walletAddress.asset.scale
       },
       destinationAsset: {
-        code: options.walletAddress.asset.code,
-        scale: options.walletAddress.asset.scale
+        code: receiveAmount.assetCode,
+        scale: receiveAmount.assetScale
       }
     })
-    if (isConvertError(converted)) {
+    if (isConvertError(convertResults)) {
       throw new PaymentMethodHandlerError(
         'Received error during local quoting',
         {
@@ -128,21 +134,23 @@ async function getQuote(
         }
       )
     }
-    debitAmountValue = converted
+    debitAmountValue = convertResults.amount
+    exchangeRate = convertResults.scaledExchangeRate
   } else if (receiver.incomingAmount) {
     receiveAmountValue = receiver.incomingAmount.value
-    const converted = await convert({
+    const convertResults = await convert({
+      reverseDirection: true,
       sourceAmount: receiveAmountValue,
       sourceAsset: {
-        code: receiver.incomingAmount.assetCode,
-        scale: receiver.incomingAmount.assetScale
+        code: walletAddress.asset.code,
+        scale: walletAddress.asset.scale
       },
       destinationAsset: {
-        code: options.walletAddress.asset.code,
-        scale: options.walletAddress.asset.scale
+        code: receiver.incomingAmount.assetCode,
+        scale: receiver.incomingAmount.assetScale
       }
     })
-    if (isConvertError(converted)) {
+    if (isConvertError(convertResults)) {
       throw new PaymentMethodHandlerError(
         'Received error during local quoting',
         {
@@ -152,7 +160,8 @@ async function getQuote(
         }
       )
     }
-    debitAmountValue = converted
+    debitAmountValue = convertResults.amount
+    exchangeRate = convertResults.scaledExchangeRate
   } else {
     throw new PaymentMethodHandlerError('Received error during local quoting', {
       description: 'No value provided to get quote from',
@@ -178,8 +187,7 @@ async function getQuote(
   return {
     receiver: options.receiver,
     walletAddress: options.walletAddress,
-    estimatedExchangeRate:
-      Number(receiveAmountValue) / Number(debitAmountValue),
+    estimatedExchangeRate: exchangeRate,
     debitAmount: {
       value: debitAmountValue,
       assetCode: options.walletAddress.asset.code,

packages/backend/src/rates/service.test.ts

@@ -81,7 +81,10 @@ describe('Rates service', function () {
           sourceAsset: { code: 'USD', scale: 9 },
           destinationAsset: { code: 'USD', scale: 9 }
         })
-      ).resolves.toBe(1234n)
+      ).resolves.toEqual({
+        amount: 1234n,
+        scaledExchangeRate: 1
+      })
       expect(apiRequestCount).toBe(0)
     })
 
@@ -92,14 +95,20 @@ describe('Rates service', function () {
           sourceAsset: { code: 'USD', scale: 9 },
           destinationAsset: { code: 'USD', scale: 12 }
         })
-      ).resolves.toBe(123_000n)
+      ).resolves.toEqual({
+        amount: 123_000n,
+        scaledExchangeRate: 1000
+      })
       await expect(
         service.convert({
           sourceAmount: 123456n,
           sourceAsset: { code: 'USD', scale: 12 },
           destinationAsset: { code: 'USD', scale: 9 }
         })
-      ).resolves.toBe(123n)
+      ).resolves.toEqual({
+        amount: 123n,
+        scaledExchangeRate: 0.001
+      })
       expect(apiRequestCount).toBe(0)
     })
 
@@ -111,14 +120,20 @@ describe('Rates service', function () {
           sourceAsset: { code: 'USD', scale: 2 },
           destinationAsset: { code: 'EUR', scale: 2 }
         })
-      ).resolves.toBe(BigInt(sourceAmount * exampleRates.USD.EUR))
+      ).resolves.toEqual({
+        amount: BigInt(sourceAmount * exampleRates.USD.EUR),
+        scaledExchangeRate: exampleRates.USD.EUR
+      })
       await expect(
         service.convert({
           sourceAmount: BigInt(sourceAmount),
           sourceAsset: { code: 'EUR', scale: 2 },
           destinationAsset: { code: 'USD', scale: 2 }
         })
-      ).resolves.toBe(BigInt(sourceAmount * exampleRates.EUR.USD))
+      ).resolves.toEqual({
+        amount: BigInt(sourceAmount * exampleRates.EUR.USD),
+        scaledExchangeRate: exampleRates.EUR.USD
+      })
     })
 
     it('returns an error when an asset price is invalid', async () => {

packages/backend/src/rates/service.ts

@@ -1,6 +1,6 @@
 import { BaseService } from '../shared/baseService'
 import Axios, { AxiosInstance, isAxiosError } from 'axios'
-import { convert, ConvertOptions } from './util'
+import { convert, convertReverse, ConvertOptions, ConvertResults } from './util'
 import { createInMemoryDataStore } from '../middleware/cache/data-stores/in-memory'
 import { CacheDataStore } from '../middleware/cache/data-stores'
 
@@ -11,11 +11,13 @@ export interface Rates {
   rates: Record<string, number>
 }
 
-export type RateConvertOpts = Omit<ConvertOptions, 'exchangeRate'>
+export type RateConvertOpts = Omit<ConvertOptions, 'exchangeRate'> & {
+  reverseDirection?: boolean
+}
 
 export interface RatesService {
   rates(baseAssetCode: string): Promise<Rates>
-  convert(opts: RateConvertOpts): Promise<bigint | ConvertError>
+  convert(opts: RateConvertOpts): Promise<ConvertResults | ConvertError>
 }
 
 interface ServiceDependencies extends BaseService {
@@ -51,22 +53,42 @@ class RatesServiceImpl implements RatesService {
     this.cachedRates = createInMemoryDataStore(deps.exchangeRatesLifetime)
   }
 
-  async convert(
-    opts: Omit<ConvertOptions, 'exchangeRate'>
-  ): Promise<bigint | ConvertError> {
-    const sameCode = opts.sourceAsset.code === opts.destinationAsset.code
-    const sameScale = opts.sourceAsset.scale === opts.destinationAsset.scale
-    if (sameCode && sameScale) return opts.sourceAmount
-    if (sameCode) return convert({ exchangeRate: 1.0, ...opts })
+  async convert(opts: RateConvertOpts): Promise<ConvertResults | ConvertError> {
+    const {
+      reverseDirection = false,
+      sourceAsset,
+      destinationAsset,
+      sourceAmount
+    } = opts
+
+    const sameCode = sourceAsset.code === destinationAsset.code
+    const sameScale = sourceAsset.scale === destinationAsset.scale
+    if (sameCode && sameScale)
+      return { amount: sourceAmount, scaledExchangeRate: 1 }
+
+    const conversionFn = reverseDirection ? convertReverse : convert
 
-    const { rates } = await this.getRates(opts.sourceAsset.code)
+    if (sameCode)
+      return conversionFn({
+        exchangeRate: 1.0,
+        sourceAsset,
+        destinationAsset,
+        sourceAmount
+      })
 
-    const destinationExchangeRate = rates[opts.destinationAsset.code]
+    const { rates } = await this.getRates(sourceAsset.code)
+
+    const destinationExchangeRate = rates[destinationAsset.code]
     if (!destinationExchangeRate || !isValidPrice(destinationExchangeRate)) {
       return ConvertError.InvalidDestinationPrice
     }
 
-    return convert({ exchangeRate: destinationExchangeRate, ...opts })
+    return conversionFn({
+      exchangeRate: destinationExchangeRate,
+      sourceAsset,
+      destinationAsset,
+      sourceAmount
+    })
   }
 
   async rates(baseAssetCode: string): Promise<Rates> {