feat: accept peering request

packages/backend/src/app.ts

@@ -487,8 +487,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
+  }
 }