feat: accept peering request (interledger#1849)

* feat(backend): WIP - add feeid to quote table

* refactor(backend): rename quote gql field

* fix(backend): add fee relation

* feat(backend): WIP calculate fees in quote create

* refactor(backend): rename gql quote field

* fix(backend): rm unused with graph fetched

* feat(backend): move fee calculation to quote service

* fix(backend): use quote error

* fix(backend): rm unused fn

* refactor(backend): rename quote send amount value

* refactor(backend): rename quote send amount to debit amount

* refactor(backend): rename out payment send amount to debit

* chore(backend): format

* chore(documentation): update gql docs

* fix(backend,localenv): trx amount

* fix(backend): handle cross currency fee in quote

* refactor: update spec and rename more fields

* fix(backend): outgoing limit test

* refactor(backend): rename limits field

* rename sendAmount to debitAmount

* fix(localenv): postman ecommerce flow

* fix(backend): remove useless checks

* chore(auth): update open-payments package version

* chore(backend): rm commented out code

* fix(auth): migration to rename jsonb col

* chore(auth): format

* feat: add DuplicatePeer error

* fix: pass in peerService to autoPeeringService

* chore: update diff

* chore: add to peer resolver test

* feat: accept peering request

* fix(backend): remove asset join

* refactor(backend): remove variable assignment

* feat: wire up router for auto peering

* fix: update auto peering service

* feat: correct config

* config: update auto peering routes & errors

* chore: prettier

* chore: address comments

* Update packages/backend/src/auto-peering/errors.ts

Co-authored-by: Radu-Cristian Popa <[email protected]>

* chore: remove axios from app

* chore: fix whitespace

* feature(backend): change error

* reactor(documentation): update fee explanation

* feat: use assetId in getByDestinationAddress

* feat: update peer on duplicate peering request

* chore: remove quote url references

* fix(openapi): missing server warning

* chore: fix route tests

* feat: support maxPacketAmount and name in peering request

* feat: support maxPacketAmount and name in peering request

* fix: remove getter

* Temporary fix

* chore(token-introspection): generate types

* refactor(documentation): rename sendAmount to debitAmount

* Revert "Merge branch 'bc/1639/add-fees-to-quote' into mk/1802/accept-peering-request"

This reverts commit 8fb0154, reversing
changes made to 9619132.

* ci: test heap bump

* ci: logheapusage

* chore: bump jest

* chore: update tests

* chore: update tests

* Revert "ci: logheapusage"

This reverts commit 66293e5.

* revert fix

* fix: revert pnpm lock

---------

Co-authored-by: Blair Currey <[email protected]>
Co-authored-by: Radu-Cristian Popa <[email protected]>

Author: 3 people

packages/backend/src/app.ts

@@ -588,8 +588,7 @@ export class App {
     const router = new Router<DefaultState, AppContext>()
 
     router.use(bodyParser())
-
-    router.get('/', autoPeeringRoutes.get)
+    router.post('/', autoPeeringRoutes.acceptPeerRequest)
 
     koa.use(router.routes())
 

packages/backend/src/auto-peering/errors.ts

@@ -0,0 +1,38 @@
+export enum AutoPeeringError {
+  InvalidIlpConfiguration = 'InvalidIlpConfiguration',
+  InvalidPeerIlpConfiguration = 'InvalidPeerIlpConfiguration',
+  UnknownAsset = 'UnknownAsset',
+  PeerUnsupportedAsset = 'PeerUnsupportedAsset',
+  InvalidPeerUrl = 'InvalidPeerUrl',
+  InvalidPeeringRequest = 'InvalidPeeringRequest',
+  DuplicatePeer = 'DuplicatePeer'
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+export const isAutoPeeringError = (o: any): o is AutoPeeringError =>
+  Object.values(AutoPeeringError).includes(o)
+
+export const errorToCode: {
+  [key in AutoPeeringError]: number
+} = {
+  [AutoPeeringError.InvalidIlpConfiguration]: 400,
+  [AutoPeeringError.InvalidPeerIlpConfiguration]: 400,
+  [AutoPeeringError.UnknownAsset]: 404,
+  [AutoPeeringError.PeerUnsupportedAsset]: 400,
+  [AutoPeeringError.InvalidPeerUrl]: 400,
+  [AutoPeeringError.InvalidPeeringRequest]: 400,
+  [AutoPeeringError.DuplicatePeer]: 409
+}
+
+export const errorToMessage: {
+  [key in AutoPeeringError]: string
+} = {
+  [AutoPeeringError.InvalidIlpConfiguration]:
+    'The ILP configuration is misconfigured',
+  [AutoPeeringError.InvalidPeerIlpConfiguration]: `Requested peer's ILP configuration is misconfigured`,
+  [AutoPeeringError.UnknownAsset]: 'Unknown asset',
+  [AutoPeeringError.PeerUnsupportedAsset]: 'Peer does not support asset',
+  [AutoPeeringError.InvalidPeerUrl]: 'Peer URL is invalid',
+  [AutoPeeringError.InvalidPeeringRequest]: 'Invalid peering request',
+  [AutoPeeringError.DuplicatePeer]: 'Duplicate peer'
+}

packages/backend/src/auto-peering/routes.test.ts

@@ -1,22 +1,25 @@
 import { IocContract } from '@adonisjs/fold'
 import { initIocContainer } from '..'
-import { AppContext, AppServices } from '../app'
-import { Config } from '../config/app'
+import { AppServices } from '../app'
+import { Config, IAppConfig } from '../config/app'
 import { createTestApp, TestContainer } from '../tests/app'
 import { createAsset } from '../tests/asset'
 import { createContext } from '../tests/context'
 import { truncateTables } from '../tests/tableManager'
-import { AutoPeeringRoutes } from './routes'
+import { AutoPeeringError, errorToCode, errorToMessage } from './errors'
+import { AutoPeeringRoutes, PeerRequestContext } from './routes'
 
 describe('Auto Peering Routes', (): void => {
   let deps: IocContract<AppServices>
   let appContainer: TestContainer
   let autoPeeringRoutes: AutoPeeringRoutes
+  let config: IAppConfig
 
   beforeAll(async (): Promise<void> => {
     deps = initIocContainer({ ...Config, enableAutoPeering: true })
     appContainer = await createTestApp(deps)
     autoPeeringRoutes = await deps.use('autoPeeringRoutes')
+    config = await deps.use('config')
   })
 
   afterEach(async (): Promise<void> => {
@@ -27,41 +30,56 @@ describe('Auto Peering Routes', (): void => {
     await appContainer.shutdown()
   })
 
-  describe('get', (): void => {
-    test('returns peering details with assets', async (): Promise<void> => {
-      const assets = await Promise.all([
-        createAsset(deps),
-        createAsset(deps),
-        createAsset(deps)
-      ])
+  describe('acceptPeerRequest', (): void => {
+    test('returns peering details', async (): Promise<void> => {
+      const asset = await createAsset(deps)
 
-      const ctx = createContext<AppContext>({
+      const ctx = createContext<PeerRequestContext>({
         headers: { Accept: 'application/json' },
-        url: `/`
+        url: `/`,
+        body: {
+          staticIlpAddress: 'test.rafiki-money',
+          ilpConnectorAddress: 'http://peer.rafiki.money',
+          asset: { code: asset.code, scale: asset.scale },
+          httpToken: 'someHttpToken',
+          maxPacketAmount: 1000,
+          name: 'Rafiki Money'
+        }
       })
 
-      await expect(autoPeeringRoutes.get(ctx)).resolves.toBeUndefined()
+      await expect(
+        autoPeeringRoutes.acceptPeerRequest(ctx)
+      ).resolves.toBeUndefined()
+      expect(ctx.status).toBe(200)
       expect(ctx.body).toEqual({
-        ilpAddress: Config.ilpAddress,
-        assets: expect.arrayContaining(
-          assets.map((asset) => ({
-            code: asset.code,
-            scale: asset.scale
-          }))
-        )
+        staticIlpAddress: config.ilpAddress,
+        ilpConnectorAddress: config.ilpConnectorAddress,
+        httpToken: expect.any(String),
+        name: config.instanceName
       })
     })
 
-    test('returns peering details without assets', async (): Promise<void> => {
-      const ctx = createContext<AppContext>({
+    test('properly handles error', async (): Promise<void> => {
+      const ctx = createContext<PeerRequestContext>({
         headers: { Accept: 'application/json' },
-        url: `/`
+        url: `/`,
+        body: {
+          staticIlpAddress: 'test.rafiki-money',
+          ilpConnectorAddress: 'http://peer.rafiki.money',
+          asset: { code: 'ABC', scale: 2 },
+          httpToken: 'someHttpToken'
+        }
       })
 
-      await expect(autoPeeringRoutes.get(ctx)).resolves.toBeUndefined()
+      await expect(
+        autoPeeringRoutes.acceptPeerRequest(ctx)
+      ).resolves.toBeUndefined()
+      expect(ctx.status).toBe(errorToCode[AutoPeeringError.UnknownAsset])
       expect(ctx.body).toEqual({
-        ilpAddress: Config.ilpAddress,
-        assets: []
+        error: {
+          code: errorToCode[AutoPeeringError.UnknownAsset],
+          message: errorToMessage[AutoPeeringError.UnknownAsset]
+        }
       })
     })
   })

packages/backend/src/auto-peering/routes.ts

@@ -1,13 +1,29 @@
 import { AppContext } from '../app'
 import { BaseService } from '../shared/baseService'
+import { errorToCode, errorToMessage, isAutoPeeringError } from './errors'
 import { AutoPeeringService } from './service'
 
+interface PeeringRequestArgs {
+  staticIlpAddress: string
+  ilpConnectorAddress: string
+  asset: { code: string; scale: number }
+  httpToken: string
+  maxPacketAmount?: number
+  name?: string
+}
+
+export type PeerRequestContext = Exclude<AppContext, 'request'> & {
+  request: {
+    body: PeeringRequestArgs
+  }
+}
+
 export interface ServiceDependencies extends BaseService {
   autoPeeringService: AutoPeeringService
 }
 
 export interface AutoPeeringRoutes {
-  get(ctx: AppContext): Promise<void>
+  acceptPeerRequest(ctx: PeerRequestContext): Promise<void>
 }
 
 export async function createAutoPeeringRoutes(
@@ -21,15 +37,28 @@ export async function createAutoPeeringRoutes(
   }
 
   return {
-    get: (ctx: AppContext) => getPeeringDetails(deps, ctx)
+    acceptPeerRequest: (ctx: PeerRequestContext) => acceptPeerRequest(deps, ctx)
   }
 }
 
-async function getPeeringDetails(
+async function acceptPeerRequest(
   deps: ServiceDependencies,
-  ctx: AppContext
+  ctx: PeerRequestContext
 ): Promise<void> {
-  const peeringDetails = await deps.autoPeeringService.getPeeringDetails()
+  const peeringDetailsOrError =
+    await deps.autoPeeringService.acceptPeeringRequest(ctx.request.body)
 
-  ctx.body = peeringDetails
+  if (isAutoPeeringError(peeringDetailsOrError)) {
+    const errorCode = errorToCode[peeringDetailsOrError]
+    ctx.status = errorCode
+    ctx.body = {
+      error: {
+        code: errorCode,
+        message: errorToMessage[peeringDetailsOrError]
+      }
+    }
+  } else {
+    ctx.status = 200
+    ctx.body = peeringDetailsOrError
+  }
 }