[LW 9904] "UTxO Fully Depleted" error in send flow

apps/browser-extension-wallet/package.json

@@ -53,6 +53,7 @@
     "@lace/cardano": "0.1.0",
     "@lace/common": "0.1.0",
     "@lace/core": "0.1.0",
+    "@lace/icons": "workspace:^",
     "@lace/shared-wallets": "workspace:^",
     "@lace/staking": "0.1.0",
     "@lace/translation": "0.1.0",

apps/browser-extension-wallet/src/hooks/__tests__/useMaxAda.test.ts

@@ -1,13 +1,24 @@
+/* eslint-disable sonarjs/no-identical-functions */
+/* eslint-disable no-magic-numbers */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { useMaxAda } from '../useMaxAda';
+import { useMaxAda, UTXO_DEPLETED_ADA_BUFFER } from '../useMaxAda';
 import { renderHook } from '@testing-library/react-hooks';
 import { mockWalletInfoTestnet } from '@src/utils/mocks/test-helpers';
 import { Subject, of } from 'rxjs';
 import { Wallet } from '@lace/cardano';
 import { waitFor } from '@testing-library/react';
 import { act } from 'react-dom/test-utils';
-const mockInitializeTx = jest.fn();
 
+const MIN_COINS_FOR_TOKENS = 1_155_080;
+const TX_FEE = 155_381;
+
+const inspect = jest.fn();
+const mockCreateTxBuilder = jest.fn().mockReturnValue({
+  inspect,
+  build: jest.fn().mockReturnThis(),
+  addOutput: jest.fn().mockReturnThis(),
+  removeOutput: jest.fn().mockReturnThis()
+});
 const inMemoryWallet = {
   balance: {
     utxo: {
@@ -18,7 +29,7 @@ const inMemoryWallet = {
     }
   },
   protocolParameters$: of({ coinsPerUtxoByte: 4310, maxValueSize: 5000 }),
-  initializeTx: mockInitializeTx
+  createTxBuilder: mockCreateTxBuilder
 };
 
 jest.mock('../../stores', () => ({
@@ -30,17 +41,26 @@ jest.mock('../../stores', () => ({
   })
 }));
 
+const outputMap = new Map();
+
+jest.mock('../../views/browser-view/features/send-transaction', () => ({
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ...jest.requireActual<any>('../../views/browser-view/features/send-transaction'),
+  useTransactionProps: () => ({
+    outputMap
+  })
+}));
+
 describe('Testing useMaxAda hook', () => {
   beforeEach(() => {
-    mockInitializeTx.mockImplementationOnce(() => ({
+    inspect.mockResolvedValue({
       inputSelection: {
-        // eslint-disable-next-line no-magic-numbers
-        fee: BigInt(155_381)
+        fee: BigInt(TX_FEE)
       }
-    }));
+    });
   });
   afterEach(() => {
-    jest.resetAllMocks();
+    jest.clearAllMocks();
   });
 
   test('should return 0 in case balance is empty', async () => {
@@ -60,8 +80,8 @@ describe('Testing useMaxAda hook', () => {
   });
 
   test('should return 0 in case there is an error', async () => {
-    mockInitializeTx.mockReset();
-    mockInitializeTx.mockImplementation(async () => {
+    inspect.mockReset();
+    inspect.mockImplementation(async () => {
       throw new Error('init tx error');
     });
     const { result } = renderHook(() => useMaxAda());
@@ -74,19 +94,39 @@ describe('Testing useMaxAda hook', () => {
     });
   });
 
-  test('should return 7874869', async () => {
+  test('should return 0 if balance is minimum for coins', async () => {
+    const { result } = renderHook(() => useMaxAda());
+    act(() => {
+      inMemoryWallet.balance.utxo.available$.next({
+        coins: BigInt(MIN_COINS_FOR_TOKENS) + BigInt(TX_FEE),
+        assets: new Map([
+          [
+            Wallet.Cardano.AssetId('659f2917fb63f12b33667463ee575eeac1845bbc736b9c0bbc40ba8254534c41'),
+            BigInt('100000000')
+          ]
+        ])
+      });
+    });
+
+    await waitFor(() => {
+      expect(result.current.toString()).toBe('0');
+    });
+  });
+
+  test('should return balance minus fee', async () => {
     const { result } = renderHook(() => useMaxAda());
 
     act(() => {
       inMemoryWallet.balance.utxo.available$.next({ coins: BigInt('10000000') });
     });
     await waitFor(() => {
-      expect(result.current.toString()).toBe('7874869');
+      expect(result.current).toBe(BigInt('10000000') - BigInt(TX_FEE));
     });
   });
 
-  test('should return 7689539', async () => {
+  test('should return balance minus fee and minimun ada for tokens', async () => {
     const { result } = renderHook(() => useMaxAda());
+
     act(() => {
       inMemoryWallet.balance.utxo.available$.next({
         coins: BigInt('10000000'),
@@ -98,9 +138,58 @@ describe('Testing useMaxAda hook', () => {
         ])
       });
     });
+    await waitFor(() => {
+      expect(result.current).toBe(BigInt('10000000') - BigInt(TX_FEE) - BigInt(MIN_COINS_FOR_TOKENS));
+    });
+  });
+
+  test.each([1, 2, 3, 10])('should return balance minus fee and adaErrorBuffer times %i', async (errorCount) => {
+    inspect.mockResolvedValueOnce({
+      inputSelection: {
+        fee: BigInt(TX_FEE)
+      }
+    });
+    Array.from({ length: errorCount }).forEach(() => {
+      inspect.mockImplementationOnce(() => {
+        throw new Error('Error');
+      });
+    });
+
+    const { result } = renderHook(() => useMaxAda());
+
+    act(() => {
+      inMemoryWallet.balance.utxo.available$.next({
+        coins: BigInt('20000000')
+      });
+    });
+
+    await waitFor(() => {
+      expect(result.current).toBe(BigInt('20000000') - BigInt(TX_FEE) - BigInt(UTXO_DEPLETED_ADA_BUFFER * errorCount));
+    });
+  });
+
+  test('should return balance minus fee and adaErrorBuffer times %i', async () => {
+    inspect.mockResolvedValueOnce({
+      inputSelection: {
+        fee: BigInt(TX_FEE)
+      }
+    });
+    Array.from({ length: 11 }).forEach(() => {
+      inspect.mockImplementationOnce(() => {
+        throw new Error('Error');
+      });
+    });
+
+    const { result } = renderHook(() => useMaxAda());
+
+    act(() => {
+      inMemoryWallet.balance.utxo.available$.next({
+        coins: BigInt('20000000')
+      });
+    });
 
     await waitFor(() => {
-      expect(result.current.toString()).toBe('7689539');
+      expect(result.current).toBe(BigInt(0));
     });
   });
 });

apps/browser-extension-wallet/src/hooks/useInitializeTx.ts

@@ -1,11 +1,11 @@
+/* eslint-disable consistent-return */
 import { useEffect, useCallback } from 'react';
 import { Wallet } from '@lace/cardano';
 import { BuiltTxData, OutputsMap } from '../views/browser-view/features/send-transaction/types';
 import { useSpentBalances } from '../views/browser-view/features/send-transaction/store';
 import { useObservable } from '@lace/common';
 import { getReachedMaxAmountList } from '@src/views/browser-view/features/send-transaction/helpers';
 import { useWalletStore } from '@src/stores';
-import { useMaxAda } from './useMaxAda';
 import { UseTranslationResponse } from 'react-i18next';
 import type { TranslationKey } from '@lace/translation';
 
@@ -29,7 +29,11 @@ export const coinSelectionErrors = new Map<COIN_SELECTION_ERRORS, TranslationKey
 
 export const getErrorMessage =
   (t: UseTranslationResponse<'translation'>['t']) =>
-  (key: COIN_SELECTION_ERRORS): string => {
+  (key: COIN_SELECTION_ERRORS): string | undefined => {
+    if (key === COIN_SELECTION_ERRORS.FULLY_DEPLETED_ERROR) {
+      return;
+    }
+
     if (coinSelectionErrors.has(key)) {
       return t(coinSelectionErrors.get(key));
     }
@@ -49,16 +53,16 @@ export const useInitializeTx = (
   const assetsInfo = useObservable(inMemoryWallet.assetInfo$);
   const balance = useObservable(inMemoryWallet.balance.utxo.total$);
   const tokensUsed = useSpentBalances();
-  const spendableCoin = useMaxAda();
+  const availableRewards = useObservable(inMemoryWallet.balance.rewardAccounts.rewards$);
 
   const buildTransaction = useCallback(async () => {
     const reachedMaxAmountList = getReachedMaxAmountList({
       assets: assetsInfo,
       tokensUsed,
-      spendableCoin,
       balance,
       exceed: true,
-      cardanoCoin
+      cardanoCoin,
+      availableRewards
     });
     if (hasInvalidOutputs || reachedMaxAmountList.length > 0) {
       setBuiltTxData({
@@ -78,7 +82,9 @@ export const useInitializeTx = (
         const txBuilder = inMemoryWallet.createTxBuilder();
 
         outputsWithMissingCoins.outputs.forEach((output) => txBuilder.addOutput(output));
-        txBuilder.metadata(partialTxProps?.auxiliaryData?.blob || new Map());
+        if (partialTxProps?.auxiliaryData?.blob) {
+          txBuilder.metadata(partialTxProps.auxiliaryData.blob);
+        }
         const tx = txBuilder.build();
         const inspection = await tx.inspect();
         setBuiltTxData({
@@ -107,9 +113,9 @@ export const useInitializeTx = (
   }, [
     assetsInfo,
     tokensUsed,
-    spendableCoin,
     balance,
     cardanoCoin,
+    availableRewards,
     hasInvalidOutputs,
     setBuiltTxData,
     metadata,