fix: new getFees

__tests__/lightning.ts

@@ -0,0 +1,210 @@
+import { IBtInfo, IGetFeeEstimatesResponse } from "beignet";
+import { getFees } from "../src/utils/lightning";
+
+jest.mock('../src/utils/wallet', () => ({
+    getSelectedNetwork: jest.fn(() => 'bitcoin')
+}));
+
+describe('getFees', () => {
+    const MEMPOOL_URL = 'https://mempool.space/api/v1/fees/recommended';
+    const BLOCKTANK_URL = 'https://api1.blocktank.to/api/info';
+
+    const mockMempoolResponse: IGetFeeEstimatesResponse = {
+        fastestFee: 111,
+        halfHourFee: 110,
+        hourFee: 109,
+        minimumFee: 108,
+    };
+
+    const mockBlocktankResponse: IBtInfo = {
+        onchain: {
+            feeRates: {
+                fast: 999,
+                mid: 998,
+                slow: 997,
+            }
+        }
+    } as IBtInfo;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        (global.fetch as jest.Mock) = jest.fn(url => {
+            if (url === MEMPOOL_URL) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve(mockMempoolResponse)
+                });
+            }
+            if (url === BLOCKTANK_URL) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve(mockBlocktankResponse)
+                });
+            }
+            return Promise.reject(new Error(`Unexpected URL: ${url}`));
+        });
+    });
+
+    it('should use mempool.space when both APIs succeed', async () => {
+        const result = await getFees();
+
+        expect(result).toEqual({
+            onChainSweep: 111,
+            maxAllowedNonAnchorChannelRemoteFee: Math.max(25, 111 * 10),
+            minAllowedAnchorChannelRemoteFee: 108,
+            minAllowedNonAnchorChannelRemoteFee: 107,
+            anchorChannelFee: 109,
+            nonAnchorChannelFee: 110,
+            channelCloseMinimum: 108,
+        });
+        expect(fetch).toHaveBeenCalledTimes(2);
+        expect(fetch).toHaveBeenCalledWith(MEMPOOL_URL);
+        expect(fetch).toHaveBeenCalledWith(BLOCKTANK_URL);
+    });
+
+    it('should use blocktank when mempool.space fails', async () => {
+        (global.fetch as jest.Mock) = jest.fn(url => {
+            if (url === MEMPOOL_URL) {
+                return Promise.reject('Mempool failed');
+            }
+            if (url === BLOCKTANK_URL) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve(mockBlocktankResponse)
+                });
+            }
+            return Promise.reject(new Error(`Unexpected URL: ${url}`));
+        });
+
+        const result = await getFees();
+        expect(result).toEqual({
+            onChainSweep: 999,
+            maxAllowedNonAnchorChannelRemoteFee: Math.max(25, 999 * 10),
+            minAllowedAnchorChannelRemoteFee: 997,
+            minAllowedNonAnchorChannelRemoteFee: 996,
+            anchorChannelFee: 997,
+            nonAnchorChannelFee: 998,
+            channelCloseMinimum: 997,
+        });
+        expect(fetch).toHaveBeenCalledTimes(3);
+    });
+
+    it('should retry mempool once and succeed even if blocktank fails', async () => {
+        let mempoolAttempts = 0;
+        (global.fetch as jest.Mock) = jest.fn(url => {
+            if (url === MEMPOOL_URL) {
+                mempoolAttempts++;
+                return mempoolAttempts === 1 
+                    ? Promise.reject('First mempool try failed')
+                    : Promise.resolve({
+                        ok: true,
+                        json: () => Promise.resolve(mockMempoolResponse)
+                    });
+            }
+            if (url === BLOCKTANK_URL) {
+                return Promise.reject('Blocktank failed');
+            }
+            return Promise.reject(new Error(`Unexpected URL: ${url}`));
+        });
+
+        const result = await getFees();
+        expect(result.onChainSweep).toBe(111);
+        expect(fetch).toHaveBeenCalledTimes(4);
+        expect(fetch).toHaveBeenCalledWith(MEMPOOL_URL);
+        expect(fetch).toHaveBeenCalledWith(BLOCKTANK_URL);
+    });
+
+    it('should throw error when all fetches fail', async () => {
+        (global.fetch as jest.Mock) = jest.fn(url => {
+            if (url === MEMPOOL_URL || url === BLOCKTANK_URL) {
+                return Promise.reject('API failed');
+            }
+            return Promise.reject(new Error(`Unexpected URL: ${url}`));
+        });
+
+        await expect(getFees()).rejects.toThrow();
+        expect(fetch).toHaveBeenCalledTimes(4);
+    });
+
+    it('should handle invalid mempool response', async () => {
+        (global.fetch as jest.Mock) = jest.fn(url => {
+            if (url === MEMPOOL_URL) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({ fastestFee: 0 })
+                });
+            }
+            if (url === BLOCKTANK_URL) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve(mockBlocktankResponse)
+                });
+            }
+            return Promise.reject(new Error(`Unexpected URL: ${url}`));
+        });
+
+        const result = await getFees();
+        expect(result.onChainSweep).toBe(999);
+    });
+
+    it('should handle invalid blocktank response', async () => {
+        (global.fetch as jest.Mock) = jest.fn(url => {
+            if (url === MEMPOOL_URL) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve(mockMempoolResponse)
+                });
+            }
+            if (url === BLOCKTANK_URL) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({ onchain: { feeRates: { fast: 0 } } })
+                });
+            }
+            return Promise.reject(new Error(`Unexpected URL: ${url}`));
+        });
+
+        const result = await getFees();
+        expect(result.onChainSweep).toBe(111);
+    });
+
+    it('should handle timeout errors gracefully', async () => {
+        // Enable fake timers
+        jest.useFakeTimers();
+
+        // Mock slow responses
+        (global.fetch as jest.Mock) = jest.fn(url => {
+            if (url === MEMPOOL_URL) {
+                return new Promise(resolve => 
+                    setTimeout(() => resolve({
+                        ok: true,
+                        json: () => Promise.resolve(mockMempoolResponse)
+                    }), 15000) // longer than timeout
+                );
+            }
+            if (url === BLOCKTANK_URL) {
+                return new Promise(resolve => 
+                    setTimeout(() => resolve({
+                        ok: true,
+                        json: () => Promise.resolve(mockBlocktankResponse)
+                    }), 15000) // longer than timeout
+                );
+            }
+            return Promise.reject(new Error(`Unexpected URL: ${url}`));
+        });
+
+        // Start the getFees call (don't await yet)
+        const feesPromise = getFees();
+
+        // Fast-forward past the timeout
+        jest.advanceTimersByTime(11000);
+
+        // Now await the promise and expect it to fail
+        await expect(feesPromise).rejects.toThrow();
+        expect(fetch).toHaveBeenCalledTimes(2);
+
+        // Restore real timers
+        jest.useRealTimers();
+    });
+});
+

src/navigation/bottom-sheet/SendNavigation.tsx

@@ -117,7 +117,7 @@ const SendNavigation = (): ReactElement => {
 
 	const onOpen = async (): Promise<void> => {
 		if (!transaction?.lightningInvoice) {
-			await updateOnchainFeeEstimates({ selectedNetwork, forceUpdate: true });
+			await updateOnchainFeeEstimates({ forceUpdate: true });
 			if (!transaction?.inputs.length) {
 				await setupOnChainTransaction();
 			}

src/screens/Settings/AddressViewer/index.tsx

@@ -750,13 +750,8 @@ const AddressViewer = ({
 			// Switching networks requires us to reset LDK.
 			await setupLdk({ selectedWallet, selectedNetwork });
 			// Start wallet services with the newly selected network.
-			await startWalletServices({
-				selectedNetwork: config.selectedNetwork,
-			});
-			await updateOnchainFeeEstimates({
-				selectedNetwork: config.selectedNetwork,
-				forceUpdate: true,
-			});
+			await startWalletServices({ selectedNetwork: config.selectedNetwork });
+			await updateOnchainFeeEstimates({ forceUpdate: true });
 			updateActivityList();
 			await syncLedger();
 		}

src/store/actions/wallet.ts

@@ -663,7 +663,6 @@ export const setWalletData = async <K extends keyof IWalletData>(
 			case 'feeEstimates': {
 				const feeEstimates = data2 as IWalletData[typeof value];
 				updateOnchainFeeEstimates({
-					selectedNetwork: getNetworkFromBeignet(network),
 					feeEstimates,
 					forceUpdate: true,
 				});

src/store/utils/fees.ts

@@ -1,20 +1,14 @@
-import { ok, err, Result } from '@synonymdev/result';
+import { IOnchainFees } from 'beignet';
+import { Result, err, ok } from '@synonymdev/result';
 
+import { getOnChainWalletAsync } from '../../utils/wallet';
 import { dispatch, getFeesStore } from '../helpers';
 import { updateOnchainFees } from '../slices/fees';
-import { getFeeEstimates } from '../../utils/wallet/transactions';
-import { EAvailableNetwork } from '../../utils/networks';
-import { getOnChainWalletAsync, getSelectedNetwork } from '../../utils/wallet';
-import { IOnchainFees } from 'beignet';
-
-export const REFRESH_INTERVAL = 60 * 30; // in seconds, 30 minutes
 
 export const updateOnchainFeeEstimates = async ({
-	selectedNetwork = getSelectedNetwork(),
 	forceUpdate = false,
 	feeEstimates,
 }: {
-	selectedNetwork: EAvailableNetwork;
 	forceUpdate?: boolean;
 	feeEstimates?: IOnchainFees;
 }): Promise<Result<string>> => {
@@ -24,12 +18,7 @@ export const updateOnchainFeeEstimates = async ({
 	}
 
 	if (!feeEstimates) {
-		const timestamp = feesStore.onchain.timestamp;
-		const difference = Math.floor((Date.now() - timestamp) / 1000);
-		if (!forceUpdate && difference < REFRESH_INTERVAL) {
-			return ok('On-chain fee estimates are up to date.');
-		}
-		const feeEstimatesRes = await getFeeEstimates(selectedNetwork);
+		const feeEstimatesRes = await refreshOnchainFeeEstimates({ forceUpdate });
 		if (feeEstimatesRes.isErr()) {
 			return err(feeEstimatesRes.error);
 		}

src/utils/helpers.ts

@@ -5,6 +5,12 @@ import ReactNativeHapticFeedback from 'react-native-haptic-feedback';
 
 import { i18nTime } from '../utils/i18n';
 
+/**
+ * Returns the result of a promise, or an error if the promise takes too long to resolve.
+ * @param {number} ms The time to wait in milliseconds.
+ * @param {Promise<any>} promise The promise to resolve.
+ * @returns {Promise<T>}
+ */
 export const promiseTimeout = <T>(
 	ms: number,
 	promise: Promise<any>,