feat: 1658 gatehub add tests for gatehub module

.vscode/launch.json

@@ -10,6 +10,24 @@
       "localRoot": "${workspaceFolder}/packages/wallet/backend",
       "remoteRoot": "/home/testnet/packages/wallet/backend",
       "protocol": "inspector"
+    },
+    {
+      // debugs jest test file in wallet backend
+      "type": "node",
+      "request": "launch",
+      "name": "Wallet Backend-Jest Test File",
+      "program": "${workspaceFolder}/packages/wallet/backend/node_modules/jest/bin/jest.js",
+      "args": [
+        "--runTestsByPath",
+        "${relativeFile}",
+        "--config",
+        "packages/wallet/backend/jest.config.json"
+      ],
+      "console": "integratedTerminal",
+      "internalConsoleOptions": "neverOpen",
+      "windows": {
+        "program": "${workspaceFolder}/packages/wallet/backend/node_modules/jest/bin/jest.js"
+      }
     }
   ]
 }

package.json

@@ -29,8 +29,8 @@
     "localenv:start:lite": "cross-env DEV_MODE=lite pnpm compose up -d --build",
     "localenv:stop": "pnpm compose down",
     "preinstall": "npx only-allow pnpm",
-    "prettier:write": "prettier --config '.prettierrc.js' --write .",
-    "prettier:check": "prettier --config '.prettierrc.js' --check .",
+    "prettier:write": "prettier --config \".prettierrc.js\" --write .",
+    "prettier:check": "prettier --config \".prettierrc.js\" --check .",
     "prod": "pnpm compose:prod up -d --build",
     "prod:down": "pnpm compose:prod down",
     "wallet:backend": "pnpm --filter @wallet/backend --",

packages/wallet/backend/src/rafiki/controller.ts

@@ -4,7 +4,7 @@ import { RatesService } from '@/rates/service'
 import { ratesSchema } from '@/rates/validation'
 import { validate } from '@/shared/validate'
 import { RafikiService } from './service'
-import { webhookSchema } from './validation'
+import { webhookBodySchema } from './validation'
 import { RatesResponse } from '@wallet/shared'
 interface IRafikiController {
   getRates: (
@@ -39,7 +39,7 @@ export class RafikiController implements IRafikiController {
 
   onWebHook = async (req: Request, res: Response, next: NextFunction) => {
     try {
-      const wh = await validate(webhookSchema, req)
+      const wh = await validate(webhookBodySchema, req)
 
       await this.rafikiService.onWebHook(wh.body)
       res.status(200).send()

packages/wallet/backend/src/rafiki/service.ts

@@ -11,6 +11,14 @@ import MessageType from '@/socket/messageType'
 import { BadRequest } from '@shared/backend'
 import { GateHubClient } from '@/gatehub/client'
 import { TransactionTypeEnum } from '@/gatehub/consts'
+import {
+  WebhookType,
+  incomingPaymentWebhookSchema,
+  incomingPaymentCompletedWebhookSchema,
+  outgoingPaymentWebhookSchema,
+  walletAddressWebhookSchema,
+  validateInput
+} from './validation'
 
 export enum EventType {
   IncomingPaymentCreated = 'incoming_payment.created',
@@ -69,8 +77,11 @@ type Fee = {
 
 export type Fees = Record<string, Fee>
 
+const isValidEventType = (value: string): value is EventType => {
+  return Object.values(EventType).includes(value as EventType)
+}
 interface IRafikiService {
-  onWebHook: (wh: WebHook) => Promise<void>
+  onWebHook: (wh: WebhookType) => Promise<void>
 }
 
 export class RafikiService implements IRafikiService {
@@ -84,12 +95,19 @@ export class RafikiService implements IRafikiService {
     private walletAddressService: WalletAddressService
   ) {}
 
-  public async onWebHook(wh: WebHook): Promise<void> {
+  public async onWebHook(wh: WebhookType): Promise<void> {
     this.logger.info(
       `received webhook of type : ${wh.type} for : ${
-        wh.type === EventType.WalletAddressNotFound ? '' : `${wh.data.id}}`
+        wh.type === EventType.WalletAddressNotFound ? '' : `${wh.id}}`
       }`
     )
+    if (!isValidEventType(wh.type)) {
+      throw new BadRequest(`unknown event type, ${wh.type}`)
+    }
+    const isValid = await this.isValidInput(wh)
+    if (!isValid) {
+      throw new BadRequest(`Invalid Input for ${wh.type}`)
+    }
     switch (wh.type) {
       case EventType.OutgoingPaymentCreated:
         await this.handleOutgoingPaymentCreated(wh)
@@ -112,11 +130,35 @@ export class RafikiService implements IRafikiService {
       case EventType.WalletAddressNotFound:
         this.logger.warn(`${EventType.WalletAddressNotFound} received`)
         break
-      default:
-        throw new BadRequest(`unknown event type, ${wh.type}`)
     }
   }
 
+  private async isValidInput(wh: WebhookType) {
+    let validInput = false
+
+    switch (wh.type) {
+      case EventType.OutgoingPaymentCreated:
+      case EventType.OutgoingPaymentCompleted:
+      case EventType.OutgoingPaymentFailed:
+        validInput = await validateInput(outgoingPaymentWebhookSchema, wh)
+        break
+      case EventType.IncomingPaymentCompleted:
+        validInput = await validateInput(
+          incomingPaymentCompletedWebhookSchema,
+          wh
+        )
+        break
+      case EventType.IncomingPaymentCreated:
+      case EventType.IncomingPaymentExpired:
+        validInput = await validateInput(incomingPaymentWebhookSchema, wh)
+        break
+      case EventType.WalletAddressNotFound:
+        validInput = await validateInput(walletAddressWebhookSchema, wh)
+        break
+    }
+    return validInput
+  }
+
   private parseAmount(amount: AmountJSON): Amount {
     return { ...amount, value: BigInt(amount.value) }
   }
@@ -126,7 +168,8 @@ export class RafikiService implements IRafikiService {
     if (
       [
         EventType.OutgoingPaymentCreated,
-        EventType.OutgoingPaymentCompleted
+        EventType.OutgoingPaymentCompleted,
+        EventType.OutgoingPaymentFailed
       ].includes(wh.type)
     ) {
       amount = this.parseAmount(wh.data.debitAmount as AmountJSON)

packages/wallet/backend/src/rafiki/validation.ts

@@ -1,14 +1,6 @@
 import { z } from 'zod'
 import { EventType, PaymentType } from './service'
 
-export const webhookSchema = z.object({
-  body: z.object({
-    id: z.string({ required_error: 'id is required' }),
-    type: z.nativeEnum(EventType),
-    data: z.record(z.string(), z.any())
-  })
-})
-
 const quoteAmountSchema = z.object({
   value: z.coerce.bigint(),
   assetCode: z.string(),
@@ -31,3 +23,132 @@ export const quoteSchema = z.object({
     expiresAt: z.string()
   })
 })
+
+const amountSchema = z.object({
+  value: z.coerce.number(),
+  assetCode: z.string(),
+  assetScale: z.number()
+})
+
+const incomingPaymentCompletedSchema = z.object({
+  id: z.string(),
+  walletAddressId: z.string(),
+  createdAt: z.string(),
+  expiresAt: z.string(),
+  incomingAmount: amountSchema,
+  receivedAmount: amountSchema,
+  completed: z.boolean(),
+  updatedAt: z.string(),
+  metadata: z.object({
+    description: z.string()
+  })
+})
+const incomingPaymentSchema = z.object({
+  id: z.string(),
+  walletAddressId: z.string(),
+  createdAt: z.string(),
+  expiresAt: z.string(),
+  receivedAmount: amountSchema,
+  completed: z.boolean(),
+  updatedAt: z.string(),
+  metadata: z.object({
+    description: z.string()
+  })
+})
+const outgoingPaymentSchema = z.object({
+  id: z.string(),
+  walletAddressId: z.string(),
+  client: z.string(),
+  state: z.string(),
+  receiver: z.string(),
+  debitAmount: amountSchema,
+  receiveAmount: amountSchema,
+  sentAmount: amountSchema,
+  stateAttempts: z.number(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  balance: z.string(),
+  metadata: z.object({
+    description: z.string()
+  })
+})
+const outgoingPaymentCreatedSchema = z.object({
+  id: z.string(),
+  walletAddressId: z.string(),
+  client: z.string(),
+  state: z.string(),
+  receiver: z.string(),
+  debitAmount: amountSchema,
+  receiveAmount: amountSchema,
+  sentAmount: amountSchema,
+  stateAttempts: z.number(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  balance: z.string(),
+  metadata: z.object({
+    description: z.string()
+  })
+})
+export const incomingPaymentCompletedWebhookSchema = z.object({
+  id: z.string({ required_error: 'id is required' }),
+  type: z.nativeEnum(EventType),
+  data: incomingPaymentCompletedSchema
+})
+export const incomingPaymentWebhookSchema = z.object({
+  id: z.string({ required_error: 'id is required' }),
+  type: z.nativeEnum(EventType),
+  data: incomingPaymentSchema
+})
+export const outgoingPaymentCreatedWebhookSchema = z.object({
+  id: z.string({ required_error: 'id is required' }),
+  type: z.nativeEnum(EventType),
+  data: outgoingPaymentCreatedSchema
+})
+export const outgoingPaymentWebhookSchema = z.object({
+  id: z.string(),
+  type: z.nativeEnum(EventType),
+  data: outgoingPaymentSchema
+})
+export const walletAddressWebhookSchema = z.object({
+  id: z.string(),
+  type: z.nativeEnum(EventType),
+  data: z.object({
+    walletAddressUrl: z.string()
+  })
+})
+export const webhookSchema = z.union([
+  incomingPaymentCompletedWebhookSchema,
+  incomingPaymentWebhookSchema,
+  outgoingPaymentWebhookSchema,
+  walletAddressWebhookSchema
+])
+export const incomingPaymentWebhookBodySchema = z.object({
+  body: incomingPaymentWebhookSchema
+})
+export const webhookBodySchema = z.object({
+  body: webhookSchema
+})
+export type WebhookType = z.infer<typeof webhookSchema>
+
+export async function validateInput<Z extends z.AnyZodObject>(
+  schema: Z,
+  input: WebhookType
+): Promise<boolean> {
+  try {
+    const res = await schema.safeParseAsync(input)
+    if (!res.success) {
+      const errors: Record<string, string> = {}
+      res.error.issues.forEach((i) => {
+        if (i.path.length > 1) {
+          errors[i.path[1]] = i.message
+        } else {
+          errors[i.path[0]] = i.message
+        }
+      })
+      return false
+    }
+  } catch (error) {
+    return false
+  }
+  return true
+}