feat: check balance before creating swap (#663)

lib/service/BalanceCheck.ts

@@ -0,0 +1,20 @@
+import WalletManager from '../wallet/WalletManager';
+import Errors from './Errors';
+
+class BalanceCheck {
+  constructor(private readonly walletManager: WalletManager) {}
+
+  public checkBalance = async (symbol: string, amount: number) => {
+    const wallet = this.walletManager.wallets.get(symbol);
+    if (wallet === undefined) {
+      throw Errors.CURRENCY_NOT_FOUND(symbol);
+    }
+
+    const balance = await wallet.getBalance();
+    if (balance.confirmedBalance < amount) {
+      throw Errors.INSUFFICIENT_LIQUIDITY();
+    }
+  };
+}
+
+export default BalanceCheck;

lib/service/Errors.ts

@@ -197,4 +197,8 @@ export default {
     message: 'invalid quote',
     code: concatErrorCode(ErrorCodePrefix.Service, 50),
   }),
+  INSUFFICIENT_LIQUIDITY: (): Error => ({
+    message: 'insufficient liquidity',
+    code: concatErrorCode(ErrorCodePrefix.Service, 51),
+  }),
 };

lib/service/Renegotiator.ts

@@ -22,6 +22,7 @@ import {
   formatERC20SwapValues,
   formatEtherSwapValues,
 } from '../wallet/ethereum/ContractUtils';
+import BalanceCheck from './BalanceCheck';
 import Errors from './Errors';
 import TimeoutDeltaProvider from './TimeoutDeltaProvider';
 import ChainSwapSigner from './cooperative/ChainSwapSigner';
@@ -38,6 +39,7 @@ class Renegotiator {
     private readonly chainSwapSigner: ChainSwapSigner,
     private readonly eipSigner: EipSigner,
     private readonly rateProvider: RateProvider,
+    private readonly balanceCheck: BalanceCheck,
   ) {}
 
   public getQuote = async (swapId: string): Promise<number> => {
@@ -61,6 +63,11 @@ class Renegotiator {
           throw Errors.INVALID_QUOTE();
         }
 
+        await this.balanceCheck.checkBalance(
+          swap.sendingData.symbol,
+          serverLockAmount,
+        );
+
         this.logger.info(
           `Accepted new quote for ${swapTypeToPrettyString(swap.type)} Swap ${swap.id}: ${newQuote}`,
         );

lib/service/Service.ts

@@ -88,6 +88,7 @@ import { SwapNurseryEvents } from '../swap/PaymentHandler';
 import SwapManager, { ChannelCreationInfo } from '../swap/SwapManager';
 import SwapOutputType from '../swap/SwapOutputType';
 import WalletManager, { Currency } from '../wallet/WalletManager';
+import BalanceCheck from './BalanceCheck';
 import Blocks from './Blocks';
 import ElementsService from './ElementsService';
 import Errors from './Errors';
@@ -144,6 +145,7 @@ class Service {
 
   private prepayMinerFee: boolean;
 
+  private balanceCheck: BalanceCheck;
   private readonly paymentRequestUtils: PaymentRequestUtils;
   private readonly timeoutDeltaProvider: TimeoutDeltaProvider;
 
@@ -197,6 +199,7 @@ class Service {
       this.rateProvider,
     );
 
+    this.balanceCheck = new BalanceCheck(this.walletManager);
     this.swapManager = new SwapManager(
       this.logger,
       notifications,
@@ -215,6 +218,7 @@ class Service {
       config.swap,
       this.lockupTransactionTracker,
       this.sidecar,
+      this.balanceCheck,
     );
 
     this.eventHandler = new EventHandler(
@@ -1682,6 +1686,7 @@ class Service {
       args.version,
       SwapType.ReverseSubmarine,
     );
+    await this.balanceCheck.checkBalance(sendingCurrency.symbol, onchainAmount);
 
     let prepayMinerFeeInvoiceAmount: number | undefined = undefined;
     let prepayMinerFeeOnchainAmount: number | undefined = undefined;
@@ -1968,6 +1973,11 @@ class Service {
       if (args.serverLockAmount < 1) {
         throw Errors.ONCHAIN_AMOUNT_TOO_LOW();
       }
+
+      await this.balanceCheck.checkBalance(
+        sendingCurrency.symbol,
+        args.serverLockAmount,
+      );
     }
 
     const referralId = await this.getReferralId(args.referralId);

lib/swap/SwapManager.ts

@@ -60,6 +60,7 @@ import TransactionLabelRepository from '../db/repositories/TransactionLabelRepos
 import NotificationClient from '../notifications/NotificationClient';
 import LockupTransactionTracker from '../rates/LockupTransactionTracker';
 import RateProvider from '../rates/RateProvider';
+import BalanceCheck from '../service/BalanceCheck';
 import Blocks from '../service/Blocks';
 import InvoiceExpiryHelper from '../service/InvoiceExpiryHelper';
 import PaymentRequestUtils from '../service/PaymentRequestUtils';
@@ -181,6 +182,7 @@ class SwapManager {
     swapConfig: SwapConfig,
     lockupTransactionTracker: LockupTransactionTracker,
     sidecar: Sidecar,
+    balanceCheck: BalanceCheck,
   ) {
     this.deferredClaimer = new DeferredClaimer(
       this.logger,
@@ -227,6 +229,7 @@ class SwapManager {
       this.chainSwapSigner,
       this.eipSigner,
       rateProvider,
+      balanceCheck,
     );
 
     this.reverseRoutingHints = new ReverseRoutingHints(

test/integration/service/BalanceCheck.spec.ts

@@ -0,0 +1,53 @@
+import Logger from '../../../lib/Logger';
+import BalanceCheck from '../../../lib/service/BalanceCheck';
+import Errors from '../../../lib/service/Errors';
+import WalletManager from '../../../lib/wallet/WalletManager';
+import CoreWalletProvider from '../../../lib/wallet/providers/CoreWalletProvider';
+import { bitcoinClient } from '../Nodes';
+
+jest.mock('../../../lib/db/repositories/ChainTipRepository');
+
+describe('BalanceCheck', () => {
+  const wallet = new CoreWalletProvider(Logger.disabledLogger, bitcoinClient);
+  const balanceCheck = new BalanceCheck({
+    wallets: new Map<string, any>([['BTC', wallet]]),
+  } as unknown as WalletManager);
+
+  beforeAll(async () => {
+    await bitcoinClient.connect();
+  });
+
+  afterAll(() => {
+    bitcoinClient.disconnect();
+  });
+
+  test('should throw when no wallet can be found', async () => {
+    const symbol = 'notFound';
+    await expect(balanceCheck.checkBalance(symbol, 1)).rejects.toEqual(
+      Errors.CURRENCY_NOT_FOUND(symbol),
+    );
+  });
+
+  test('should not throw when amount is less than balance', async () => {
+    await balanceCheck.checkBalance(
+      'BTC',
+      (await wallet.getBalance()).confirmedBalance - 1,
+    );
+  });
+
+  test('should not throw when amount is equal balance', async () => {
+    await balanceCheck.checkBalance(
+      'BTC',
+      (await wallet.getBalance()).confirmedBalance,
+    );
+  });
+
+  test('should throw when amount is more than balance', async () => {
+    await expect(
+      balanceCheck.checkBalance(
+        'BTC',
+        (await wallet.getBalance()).confirmedBalance + 1,
+      ),
+    ).rejects.toEqual(Errors.INSUFFICIENT_LIQUIDITY());
+  });
+});

test/integration/service/Renegotiator.spec.ts

@@ -12,6 +12,7 @@ import {
 } from '../../../lib/consts/Enums';
 import ChainSwapRepository from '../../../lib/db/repositories/ChainSwapRepository';
 import RateProvider from '../../../lib/rates/RateProvider';
+import BalanceCheck from '../../../lib/service/BalanceCheck';
 import Errors from '../../../lib/service/Errors';
 import Renegotiator from '../../../lib/service/Renegotiator';
 import ChainSwapSigner from '../../../lib/service/cooperative/ChainSwapSigner';
@@ -126,6 +127,10 @@ describe('Renegotiator', () => {
     },
   } as any as RateProvider;
 
+  const balanceCheck = {
+    checkBalance: jest.fn().mockImplementation(async () => {}),
+  } as unknown as BalanceCheck;
+
   let negotiator: Renegotiator;
 
   beforeAll(async () => {
@@ -163,6 +168,7 @@ describe('Renegotiator', () => {
       chainSwapSigner,
       eipSigner,
       rateProvider,
+      balanceCheck,
     );
 
     jest.clearAllMocks();
@@ -213,6 +219,35 @@ describe('Renegotiator', () => {
       );
     });
 
+    test('should throw when balance check fails', async () => {
+      const swapId = 'someId';
+
+      ChainSwapRepository.getChainSwap = jest.fn().mockResolvedValue({
+        receivingData: {
+          symbol: 'BTC',
+          amount: 100_000,
+        },
+        sendingData: {
+          symbol: 'BTC',
+        },
+      });
+      negotiator['validateEligibility'] = jest
+        .fn()
+        .mockImplementation(async () => {});
+
+      balanceCheck.checkBalance = jest.fn().mockImplementation(async () => {
+        throw Errors.INSUFFICIENT_LIQUIDITY();
+      });
+
+      await expect(negotiator.acceptQuote(swapId, 94_877)).rejects.toEqual(
+        Errors.INSUFFICIENT_LIQUIDITY(),
+      );
+      expect(balanceCheck.checkBalance).toHaveBeenCalledTimes(1);
+      expect(balanceCheck.checkBalance).toHaveBeenCalledWith('BTC', 94_877);
+
+      balanceCheck.checkBalance = jest.fn().mockImplementation(async () => {});
+    });
+
     describe('UTXO based chain', () => {
       test.each`
         confirmed

test/unit/service/Service.spec.ts

@@ -639,6 +639,12 @@ const mockedLndClient = <jest.Mock<LndClient>>(<any>LndClient);
 
 jest.mock('../../../lib/db/repositories/ReverseRoutingHintRepository');
 
+jest.mock('../../../lib/service/BalanceCheck', () => {
+  return jest.fn().mockImplementation(() => ({
+    checkBalance: jest.fn().mockImplementation(async () => {}),
+  }));
+});
+
 describe('Service', () => {
   const configPairs = [
     {