feat: Automatically approve blocked deposits

packages/wallet/backend/src/app.ts

@@ -489,6 +489,13 @@ export class App {
 
   async processResources() {
     process.nextTick(() => this.processPendingTransactions())
+    setInterval(
+      () => {
+        const transactionService = this.container.resolve('transactionService')
+        transactionService.approveTransactions()
+      },
+      1 * 60 * 1000
+    ).unref()
   }
 
   ensureGateHubProductionEnv = async (

packages/wallet/backend/src/gatehub/client.ts

@@ -1,6 +1,7 @@
 import { createHmac } from 'crypto'
 import {
   HTTP_METHODS,
+  IApprovePendingTransaction,
   IApproveUserToGatewayRequest,
   IApproveUserToGatewayResponse,
   IConnectUserToGatewayResponse,
@@ -17,6 +18,7 @@ import {
   IGetWalletResponse,
   IOverrideUserRiskLevelRequest,
   IOverrideUserRiskLevelResponse,
+  IPendingTransaction,
   IRatesResponse,
   ITokenRequest,
   ITokenResponse,
@@ -335,6 +337,53 @@ export class GateHubClient {
     return response
   }
 
+  async approvePendingTransactions(
+    transactionUuid: string
+  ): Promise<IApprovePendingTransaction> {
+    const url = `${this.apiUrl}/core/v1/transactions/${transactionUuid}/serviceStatus`
+    const body = {
+      serviceStatus: 3,
+      substatus: 0,
+      reason: 'test'
+    }
+    const response = await this.request<IApprovePendingTransaction>(
+      'PUT',
+      url,
+      JSON.stringify(body)
+    )
+    if (response.state !== 4) {
+      throw new Error(`Approval failed, transactionUuid: ${transactionUuid}`)
+    }
+    return response
+  }
+
+  async getPendingTransactions(): Promise<IPendingTransaction[]> {
+    const url = `${this.apiUrl}/core/v1/gateways/${this.env.GATEHUB_GATEWAY_UUID}/transactions`
+    const payload = {
+      filters: {
+        state: {
+          value: 3
+        },
+        created_at: {},
+        amount: {},
+        define_range: {
+          offset: 0,
+          limit: 20
+        },
+        order: {
+          field: 'id',
+          direction: 'desc'
+        }
+      }
+    }
+    const response = await this.request<IPendingTransaction[]>(
+      'GET',
+      url,
+      JSON.stringify(payload)
+    )
+    return response
+  }
+
   async getWallet(
     userUuid: string,
     walletId: string

packages/wallet/backend/src/gatehub/types.ts

@@ -80,6 +80,50 @@ export interface IGetWalletResponse {
   address: string
 }
 
+interface IWalletInfo {
+  uuid: string
+  created_at: string
+  address: string
+  name: string
+}
+interface IGateway {
+  uuid: string
+  created_at: string
+  updated_at: string
+  status: number
+  name: string
+  terms: string
+  insurance: number
+}
+export interface IPendingTransaction {
+  uuid: string
+  state: number
+  created_at: string
+  completed_at: string
+  amount: string
+  total_amount: string
+  fee: string
+  type: number
+  status: number
+  substatus: number
+  sending_wallet: IWalletInfo
+  receiving_wallet: IWalletInfo
+  vault: IVault
+  message: string
+  reason: string
+  gateway: IGateway
+  announcement_uuid: string
+}
+
+export interface IApprovePendingTransaction extends IPendingTransaction {
+  receiving_user: {
+    uuid: string
+    email: string
+    created_at: string
+    updated_at: string
+  }
+}
+
 export interface ICreateTransactionRequest {
   amount: number
   receiving_amount?: string

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

@@ -203,6 +203,28 @@ export class TransactionService implements ITransactionService {
     }
   }
 
+  async approveTransactions() {
+    try {
+      const transactions = await this.gateHubClient.getPendingTransactions()
+      const pendingTransactions = transactions.filter(
+        (transaction) => transaction.state === 3
+      )
+      if (!pendingTransactions.length) {
+        console.log('No pending Transactions!')
+        return
+      }
+      for (const transaction of pendingTransactions) {
+        try {
+          await this.gateHubClient.approvePendingTransactions(transaction.uuid)
+        } catch (err) {
+          console.error(`Error: ${err}`)
+        }
+      }
+    } catch (err) {
+      console.error(`Automatic approval failed - ${err}`)
+    }
+  }
+
   async processPendingIncomingPayments(): Promise<string | undefined> {
     return this.knex.transaction(async (trx) => {
       // Giving a Rafiki a little more time to process the payments before we process them.