Merge pull request #829 from BoltzExchange/pending-evm-txs-grpc

feat: gRPC method to get pending EVM transactions

lib/Utils.ts

@@ -642,3 +642,6 @@ export const bigIntMax = (a: bigint, b: bigint) => (a > b ? a : b);
 
 export const roundToDecimals = (value: number, decimals: number): number =>
   Number(value.toFixed(decimals));
+
+export const removeHexPrefix = (hex: string): string =>
+  hex.startsWith('0x') ? hex.substring(2) : hex;

lib/cli/commands/GetPendingEvmTransactions.ts

@@ -0,0 +1,27 @@
+import { Arguments } from 'yargs';
+import { getHexString } from '../../Utils';
+import { GetPendingEvmTransactionsRequest } from '../../proto/boltzrpc_pb';
+import { ApiType, BuilderTypes } from '../BuilderComponents';
+import { callback, loadBoltzClient } from '../Command';
+
+export const command = 'pendingevmtransactions';
+
+export const describe = 'get pending EVM transactions';
+
+export const builder = {};
+
+export const handler = (
+  argv: Arguments<BuilderTypes<typeof builder> & ApiType>,
+) => {
+  const request = new GetPendingEvmTransactionsRequest();
+  loadBoltzClient(argv).getPendingEvmTransactions(
+    request,
+    callback((res) => {
+      return res.getTransactionsList().map((tx) => ({
+        ...tx.toObject(),
+        hash: getHexString(Buffer.from(tx.getHash() as string, 'base64')),
+        hex: getHexString(Buffer.from(tx.getHex() as string, 'base64')),
+      }));
+    }),
+  );
+};

lib/db/models/PendingEthereumTransaction.ts

@@ -3,7 +3,7 @@ import { DataTypes, Model, Sequelize } from 'sequelize';
 type PendingEthereumTransactionType = {
   hash: string;
   nonce: number;
-  etherAmount: bigint;
+  etherAmount: number;
   hex: string;
 };
 
@@ -13,7 +13,7 @@ class PendingEthereumTransaction
 {
   public hash!: string;
   public nonce!: number;
-  public etherAmount!: bigint;
+  public etherAmount!: number;
   public hex!: string;
 
   public static load = (sequelize: Sequelize): void => {

lib/grpc/GrpcServer.ts

@@ -41,6 +41,7 @@ class GrpcServer {
       getLockedFunds: grpcService.getLockedFunds,
       getPendingSweeps: grpcService.getPendingSweeps,
       getLabel: grpcService.getLabel,
+      getPendingEvmTransactions: grpcService.getPendingEvmTransactions,
       setLogLevel: grpcService.setLogLevel,
       calculateTransactionFee: grpcService.calculateTransactionFee,
       getReferrals: grpcService.getReferrals,

lib/grpc/GrpcService.ts

@@ -5,15 +5,23 @@ import { parseTransaction } from '../Core';
 import { dumpHeap } from '../HeapDump';
 import Logger, { LogLevel as BackendLevel } from '../Logger';
 import { wait } from '../PromiseUtils';
-import { getHexString, getUnixTime, stringify } from '../Utils';
+import {
+  getHexBuffer,
+  getHexString,
+  getUnixTime,
+  removeHexPrefix,
+  stringify,
+} from '../Utils';
 import { CurrencyType, swapTypeToPrettyString } from '../consts/Enums';
 import Referral, { ReferralConfig } from '../db/models/Referral';
+import PendingEthereumTransactionRepository from '../db/repositories/PendingEthereumTransactionRepository';
 import ReferralRepository from '../db/repositories/ReferralRepository';
 import TransactionLabelRepository from '../db/repositories/TransactionLabelRepository';
 import * as boltzrpc from '../proto/boltzrpc_pb';
 import { LogLevel } from '../proto/boltzrpc_pb';
 import Service from '../service/Service';
 import Sidecar from '../sidecar/Sidecar';
+import { Rsk } from '../wallet/ethereum/EvmNetworks';
 
 class GrpcService {
   constructor(
@@ -380,6 +388,52 @@ class GrpcService {
     });
   };
 
+  public getPendingEvmTransactions: handleUnaryCall<
+    boltzrpc.GetPendingEvmTransactionsRequest,
+    boltzrpc.GetPendingEvmTransactionsResponse
+  > = async (call, callback) => {
+    await this.handleCallback(call, callback, async () => {
+      const response = new boltzrpc.GetPendingEvmTransactionsResponse();
+      const txsGrpcList = response.getTransactionsList();
+
+      for (const tx of await PendingEthereumTransactionRepository.getTransactions()) {
+        const txGrpc =
+          new boltzrpc.GetPendingEvmTransactionsResponse.Transaction();
+
+        const symbol = Rsk.symbol;
+
+        txGrpc.setSymbol(symbol);
+        txGrpc.setHash(getHexBuffer(removeHexPrefix(tx.hash)));
+        txGrpc.setHex(getHexBuffer(removeHexPrefix(tx.hex)));
+        txGrpc.setNonce(tx.nonce);
+        txGrpc.setAmountSent(tx.etherAmount.toString());
+
+        {
+          const label = await TransactionLabelRepository.getLabel(tx.hash);
+          if (label !== null) {
+            txGrpc.setLabel(label.label);
+          }
+        }
+
+        {
+          const manager = this.service.walletManager.ethereumManagers.find(
+            (m) => m.hasSymbol(symbol),
+          );
+          if (manager !== undefined) {
+            const received = await manager.getClaimedAmount(tx.hex);
+            if (received !== undefined) {
+              txGrpc.setAmountReceived(received.toString());
+            }
+          }
+        }
+
+        txsGrpcList.push(txGrpc);
+      }
+
+      return response;
+    });
+  };
+
   public setLogLevel: handleUnaryCall<
     boltzrpc.SetLogLevelRequest,
     boltzrpc.SetLogLevelResponse