feat(backend)!: tenanted rates endpoints

localenv/happy-life-bank/docker-compose.yml

@@ -68,8 +68,8 @@ services:
       STREAM_SECRET: BjPXtnd00G2mRQwP/8ZpwyZASOch5sUXT5o0iR5b5wU=
       API_SECRET: iyIgCprjb9uL8wFckR+pLEkJWMB7FJhgkvqhTQR/964=
       WEBHOOK_URL: http://happy-life-bank/webhooks
-      OPEN_PAYMENTS_URL: ${HAPPY_LIFE_BANK_OPEN_PAYMENTS_URL:-http://happy-life-bank-backend}
       EXCHANGE_RATES_URL: http://happy-life-bank/rates
+      OPEN_PAYMENTS_URL: ${HAPPY_LIFE_BANK_OPEN_PAYMENTS_URL:-http://happy-life-bank-backend}
       REDIS_URL: redis://shared-redis:6379/2
       WALLET_ADDRESS_URL: ${HAPPY_LIFE_BANK_WALLET_ADDRESS_URL:-https://happy-life-bank-backend/.well-known/pay}
       ENABLE_TELEMETRY: true

packages/backend/jest.env.js

@@ -15,3 +15,4 @@ process.env.AUTH_ADMIN_API_URL = 'http://127.0.0.1:3003/graphql'
 process.env.AUTH_ADMIN_API_SECRET = 'test-secret'
 process.env.OPERATOR_TENANT_ID = 'cf5fd7d3-1eb1-4041-8e43-ba45747e9e5d'
 process.env.API_SECRET = 'KQEXlZO65jUJXakXnLxGO7dk387mt71G9tZ42rULSNU='
+process.env.EXCHANGE_RATES_URL = 'http://example.com/rates'

packages/backend/src/asset/errors.ts

@@ -3,7 +3,8 @@ import { GraphQLErrorCode } from '../graphql/errors'
 export enum AssetError {
   DuplicateAsset = 'DuplicateAsset',
   UnknownAsset = 'UnknownAsset',
-  CannotDeleteInUseAsset = 'CannotDeleteInUseAsset'
+  CannotDeleteInUseAsset = 'CannotDeleteInUseAsset',
+  NoRatesForAsset = 'NoRatesForAsset'
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
@@ -15,13 +16,15 @@ export const errorToCode: {
 } = {
   [AssetError.UnknownAsset]: GraphQLErrorCode.NotFound,
   [AssetError.DuplicateAsset]: GraphQLErrorCode.Duplicate,
-  [AssetError.CannotDeleteInUseAsset]: GraphQLErrorCode.Forbidden
+  [AssetError.CannotDeleteInUseAsset]: GraphQLErrorCode.Forbidden,
+  [AssetError.NoRatesForAsset]: GraphQLErrorCode.Forbidden
 }
 
 export const errorToMessage: {
   [key in AssetError]: string
 } = {
   [AssetError.UnknownAsset]: 'Asset not found',
   [AssetError.DuplicateAsset]: 'Asset already exists',
-  [AssetError.CannotDeleteInUseAsset]: 'Cannot delete! Asset in use.'
+  [AssetError.CannotDeleteInUseAsset]: 'Cannot delete! Asset in use.',
+  [AssetError.NoRatesForAsset]: 'Cannot create! Exchange rates URL not defined.'
 }

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

@@ -9,8 +9,8 @@ import { Pagination, SortOrder } from '../shared/baseModel'
 import { getPageTests } from '../shared/baseModel.test'
 import { createTestApp, TestContainer } from '../tests/app'
 import { createAsset, randomAsset } from '../tests/asset'
-import { truncateTables } from '../tests/tableManager'
-import { Config } from '../config/app'
+import { truncateTable, truncateTables } from '../tests/tableManager'
+import { Config, IAppConfig } from '../config/app'
 import { IocContract } from '@adonisjs/fold'
 import { initIocContainer } from '../'
 import { AppServices } from '../app'
@@ -21,22 +21,48 @@ import { isWalletAddressError } from '../open_payments/wallet_address/errors'
 import { PeerService } from '../payment-method/ilp/peer/service'
 import { isPeerError } from '../payment-method/ilp/peer/errors'
 import { CacheDataStore } from '../middleware/cache/data-stores'
+import {
+  CreateOptions,
+  TenantSettingService
+} from '../tenants/settings/service'
+import { exchangeRatesSetting } from '../tests/tenantSettings'
 
 describe('Asset Service', (): void => {
   let deps: IocContract<AppServices>
   let appContainer: TestContainer
   let assetService: AssetService
   let peerService: PeerService
   let walletAddressService: WalletAddressService
+  let tenantSettingService: TenantSettingService
+  let config: IAppConfig
 
   beforeAll(async (): Promise<void> => {
     deps = initIocContainer(Config)
     appContainer = await createTestApp(deps)
+    config = await deps.use('config')
     assetService = await deps.use('assetService')
     walletAddressService = await deps.use('walletAddressService')
+    tenantSettingService = await deps.use('tenantSettingService')
     peerService = await deps.use('peerService')
   })
 
+  beforeEach(async (): Promise<void> => {
+    const createOptions: CreateOptions = {
+      tenantId: Config.operatorTenantId,
+      setting: [exchangeRatesSetting()]
+    }
+
+    const tenantSetting = await tenantSettingService.create(createOptions)
+
+    expect(tenantSetting).toEqual([
+      expect.objectContaining({
+        tenantId: Config.operatorTenantId,
+        key: createOptions.setting[0].key,
+        value: createOptions.setting[0].value
+      })
+    ])
+  })
+
   afterEach(async (): Promise<void> => {
     await truncateTables(deps)
   })
@@ -125,6 +151,25 @@ describe('Asset Service', (): void => {
       )
     })
 
+    test('Cannot create more than one asset if no exchange rates URL is set', async (): Promise<void> => {
+      await truncateTable(appContainer.knex, 'tenantSettings')
+      config.operatorExchangeRatesUrl = undefined
+      const firstAssetOptions = {
+        ...randomAsset(),
+        tenantId: Config.operatorTenantId
+      }
+      await expect(
+        assetService.create(firstAssetOptions)
+      ).resolves.toMatchObject(firstAssetOptions)
+      const secondAssetOptions = {
+        ...randomAsset(),
+        tenantId: Config.operatorTenantId
+      }
+      await expect(assetService.create(secondAssetOptions)).resolves.toEqual(
+        AssetError.NoRatesForAsset
+      )
+    })
+
     test('Cannot create asset with scale > 255', async (): Promise<void> => {
       const options = {
         code: 'ABC',

packages/backend/src/asset/service.ts

@@ -8,6 +8,9 @@ import { AccountingService, LiquidityAccountType } from '../accounting/service'
 import { WalletAddress } from '../open_payments/wallet_address/model'
 import { Peer } from '../payment-method/ilp/peer/model'
 import { CacheDataStore } from '../middleware/cache/data-stores'
+import { TenantSettingService } from '../tenants/settings/service'
+import { TenantSettingKeys } from '../tenants/settings/model'
+import { IAppConfig } from '../config/app'
 
 export interface AssetOptions {
   code: string
@@ -56,24 +59,30 @@ export interface AssetService {
 }
 
 interface ServiceDependencies extends BaseService {
+  config: IAppConfig
   accountingService: AccountingService
+  tenantSettingService: TenantSettingService
   assetCache: CacheDataStore<Asset>
 }
 
 export async function createAssetService({
+  config,
   logger,
   knex,
   accountingService,
+  tenantSettingService,
   assetCache
 }: ServiceDependencies): Promise<AssetService> {
   const log = logger.child({
     service: 'AssetService'
   })
 
   const deps: ServiceDependencies = {
+    config,
     logger: log,
     knex,
     accountingService,
+    tenantSettingService,
     assetCache
   }
 
@@ -99,13 +108,27 @@ async function createAsset(
   }: CreateOptions
 ): Promise<Asset | AssetError> {
   try {
-    // check if exists but deleted | by code-scale
-    const deletedAsset = await Asset.query(deps.knex)
-      .whereNotNull('deletedAt')
-      .where('code', code)
-      .andWhere('scale', scale)
+    const assets = await Asset.query(deps.knex)
       .andWhere('tenantId', tenantId)
-      .first()
+      .select('*')
+
+    const sameCodeAssets = assets.find((asset) => asset.code === code)
+    if (!sameCodeAssets && assets.length > 0) {
+      const exchangeUrlSetting = await deps.tenantSettingService.get({
+        tenantId,
+        key: TenantSettingKeys.EXCHANGE_RATES_URL.name
+      })
+
+      const tenantExchangeRatesUrl = exchangeUrlSetting[0]?.value
+      if (!tenantExchangeRatesUrl && !deps.config.operatorExchangeRatesUrl) {
+        return AssetError.NoRatesForAsset
+      }
+    }
+
+    const deletedAsset = assets.find(
+      (asset) =>
+        asset.deletedAt !== null && asset.code === code && asset.scale === scale
+    )
 
     if (deletedAsset) {
       // if found, enable

packages/backend/src/config/app.ts

@@ -115,9 +115,8 @@ export const Config = {
     5
   ),
 
-  exchangeRatesUrl: process.env.EXCHANGE_RATES_URL, // optional
   exchangeRatesLifetime: +(process.env.EXCHANGE_RATES_LIFETIME || 15_000),
-
+  operatorExchangeRatesUrl: process.env.EXCHANGE_RATES_URL, // optional
   slippage: envFloat('SLIPPAGE', 0.01),
   quoteLifespan: envInt('QUOTE_LIFESPAN', 5 * 60_000), // milliseconds
 

packages/backend/src/index.ts

@@ -253,16 +253,20 @@ export function initIocContainer(
     const config = await deps.use('config')
     return createRatesService({
       logger: await deps.use('logger'),
-      exchangeRatesUrl: config.exchangeRatesUrl,
-      exchangeRatesLifetime: config.exchangeRatesLifetime
+      operatorTenantId: config.operatorTenantId,
+      operatorExchangeRatesUrl: config.operatorExchangeRatesUrl,
+      exchangeRatesLifetime: config.exchangeRatesLifetime,
+      tenantSettingService: await deps.use('tenantSettingService')
     })
   })
 
   container.singleton('internalRatesService', async (deps) => {
     return createRatesService({
       logger: await deps.use('logger'),
-      exchangeRatesUrl: config.telemetryExchangeRatesUrl,
-      exchangeRatesLifetime: config.telemetryExchangeRatesLifetime
+      operatorTenantId: config.operatorTenantId,
+      operatorExchangeRatesUrl: config.telemetryExchangeRatesUrl,
+      exchangeRatesLifetime: config.telemetryExchangeRatesLifetime,
+      tenantSettingService: await deps.use('tenantSettingService')
     })
   })
 
@@ -330,10 +334,13 @@ export function initIocContainer(
   container.singleton('assetService', async (deps) => {
     const logger = await deps.use('logger')
     const knex = await deps.use('knex')
+    const config = await deps.use('config')
     return await createAssetService({
+      config: config,
       logger: logger,
       knex: knex,
       accountingService: await deps.use('accountingService'),
+      tenantSettingService: await deps.use('tenantSettingService'),
       assetCache: await deps.use('assetCache')
     })
   })

packages/backend/src/open_payments/payment/outgoing/lifecycle.ts

@@ -117,6 +117,7 @@ export async function handleSending(
       'transaction_fee_amounts',
       payment.sentAmount,
       payment.receiveAmount,
+      payment.tenantId,
       {
         description: 'Amount sent through the network as fees',
         valueType: ValueType.DOUBLE

packages/backend/src/open_payments/payment/outgoing/service.test.ts

@@ -55,6 +55,11 @@ import { getPageTests } from '../../../shared/baseModel.test'
 import { Pagination, SortOrder } from '../../../shared/baseModel'
 import { ReceiverService } from '../../receiver/service'
 import { WalletAddressService } from '../../wallet_address/service'
+import { CreateOptions } from '../../../tenants/settings/service'
+import {
+  createTenantSettings,
+  exchangeRatesSetting
+} from '../../../tests/tenantSettings'
 
 describe('OutgoingPaymentService', (): void => {
   let deps: IocContract<AppServices>
@@ -248,15 +253,8 @@ describe('OutgoingPaymentService', (): void => {
   }
 
   beforeAll(async (): Promise<void> => {
-    const exchangeRatesUrl = 'https://test.rates'
-
-    mockRatesApi(exchangeRatesUrl, () => ({
-      XRP: exchangeRate
-    }))
-
     deps = await initIocContainer({
       ...Config,
-      exchangeRatesUrl,
       enableTelemetry: true,
       localCacheDuration: 0
     })
@@ -274,6 +272,16 @@ describe('OutgoingPaymentService', (): void => {
 
   beforeEach(async (): Promise<void> => {
     tenantId = config.operatorTenantId
+    const createOptions: CreateOptions = {
+      tenantId,
+      setting: [exchangeRatesSetting()]
+    }
+    const tenantSetting = createTenantSettings(deps, createOptions)
+    const tenantExchangeRatesUrl = (await tenantSetting).value
+    mockRatesApi(tenantExchangeRatesUrl, () => ({
+      XRP: exchangeRate
+    }))
+
     const { id: sendAssetId } = await createAsset(deps, asset)
     assetId = sendAssetId
     const walletAddress = await createWalletAddress(deps, {

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

@@ -40,11 +40,14 @@ export function createBalanceMiddleware(): ILPMiddleware {
     }
 
     const sourceAmount = BigInt(amount)
-    const destinationAmountOrError = await services.rates.convertSource({
-      sourceAmount,
-      sourceAsset: accounts.incoming.asset,
-      destinationAsset: accounts.outgoing.asset
-    })
+    const destinationAmountOrError = await services.rates.convertSource(
+      {
+        sourceAmount,
+        sourceAsset: accounts.incoming.asset,
+        destinationAsset: accounts.outgoing.asset
+      },
+      accounts.outgoing.tenantId
+    )
     if (isConvertError(destinationAmountOrError)) {
       logger.error(
         {

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

@@ -36,6 +36,7 @@ import {
 //   ../../peer/model
 export interface ConnectorAccount extends LiquidityAccount {
   asset: LiquidityAccount['asset'] & AssetOptions
+  tenantId: string
 }
 
 export interface IncomingAccount extends ConnectorAccount {
@@ -205,7 +206,8 @@ export class Rafiki<T = any> {
       response,
       code,
       scale,
-      telemetry
+      telemetry,
+      sourceAccount.tenantId
     )
     return response.rawReply
   }

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

@@ -39,7 +39,8 @@ export async function incrementAmount(
   response: IlpResponse,
   code: string,
   scale: number,
-  telemetry: TelemetryService
+  telemetry: TelemetryService,
+  tenantId?: string
 ): Promise<void> {
   if (!unfulfillable && Number(prepareAmount) && response.fulfill) {
     const value = BigInt(prepareAmount)
@@ -50,6 +51,7 @@ export async function incrementAmount(
         assetCode: code,
         assetScale: scale
       },
+      tenantId,
       {
         description: 'Amount sent through the network',
         valueType: ValueType.DOUBLE

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

@@ -176,7 +176,12 @@ describe('Connector Core Telemetry', () => {
       telemetryService
     )
 
-    expect(incrementCounterSpy).toHaveBeenCalledWith(name, amount, attributes)
+    expect(incrementCounterSpy).toHaveBeenCalledWith(
+      name,
+      amount,
+      undefined,
+      attributes
+    )
   })
 
   it('incrementAmount should not increment when the prepare is unfulfillable', () => {