lightning.test.ts

import { IBtInfo, IGetFeeEstimatesResponse } from 'beignet';
import { checkRgsHealth, getFees } from '../src/utils/lightning';

jest.mock('../src/utils/wallet', () => ({
	getSelectedNetwork: jest.fn(() => 'bitcoin'),
}));

jest.mock('../src/store/helpers', () => ({
	getStore: jest.fn(() => ({
		settings: {
			rapidGossipSyncUrl: 'https://rgs.blocktank.to/snapshots/',
		},
	})),
}));

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({
			maxAllowedNonAnchorChannelRemoteFee: Math.max(25, 111 * 10),
			minAllowedAnchorChannelRemoteFee: 108,
			minAllowedNonAnchorChannelRemoteFee: 107,
			anchorChannelFee: 109,
			nonAnchorChannelFee: 110,
			channelCloseMinimum: 108,
			outputSpendingFee: 111,
			maximumFeeEstimate: 111 * 10,
			urgentOnChainSweep: 111,
		});
		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({
			maxAllowedNonAnchorChannelRemoteFee: Math.max(25, 999 * 10),
			minAllowedAnchorChannelRemoteFee: 997,
			minAllowedNonAnchorChannelRemoteFee: 996,
			anchorChannelFee: 997,
			nonAnchorChannelFee: 998,
			channelCloseMinimum: 997,
			outputSpendingFee: 999,
			maximumFeeEstimate: 999 * 10,
			urgentOnChainSweep: 999,
		});
		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.urgentOnChainSweep).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.urgentOnChainSweep).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.urgentOnChainSweep).toBe(111);
	});

	it('should handle timeout errors gracefully', async () => {
		jest.useFakeTimers();

		(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}`));
		});

		const feesPromise = getFees();

		jest.advanceTimersByTime(11000);

		await expect(feesPromise).rejects.toThrow();
		expect(fetch).toHaveBeenCalledTimes(2);

		jest.useRealTimers();
	});
});

describe('checkRgsHealth', () => {
	const RGS_URL = 'https://rgs.blocktank.to/snapshots/';

	beforeEach(() => {
		jest.clearAllMocks();
	});

	it('should detect healthy RGS (< 24 hours old)', async () => {
		const nowSeconds = Math.floor(Date.now() / 1000);
		const recentTimestamp = nowSeconds - 3600 * 12; // 12 hours ago

		const mockHtml = `
			<a href="snapshot__calculated-at%3A${recentTimestamp}__range%3A10800-scope.lngossip">snapshot</a>
		`;

		(global.fetch as jest.Mock) = jest.fn(() =>
			Promise.resolve({
				ok: true,
				text: () => Promise.resolve(mockHtml),
			}),
		);

		const result = await checkRgsHealth();

		expect(result.isOk()).toBe(true);
		if (result.isOk()) {
			expect(result.value.isHealthy).toBe(true);
			expect(result.value.timestamp).toBe(recentTimestamp);
			expect(result.value.ageHours).toBeGreaterThan(11);
			expect(result.value.ageHours).toBeLessThan(13);
		}
		expect(fetch).toHaveBeenCalledWith(RGS_URL);
	});

	it('should detect stale RGS (> 24 hours old)', async () => {
		const nowSeconds = Math.floor(Date.now() / 1000);
		const staleTimestamp = nowSeconds - 3600 * 48; // 48 hours ago (2 days)

		const mockHtml = `
			<a href="snapshot__calculated-at%3A${staleTimestamp}__range%3A10800-scope.lngossip">snapshot</a>
		`;

		(global.fetch as jest.Mock) = jest.fn(() =>
			Promise.resolve({
				ok: true,
				text: () => Promise.resolve(mockHtml),
			}),
		);

		const result = await checkRgsHealth();

		expect(result.isOk()).toBe(true);
		if (result.isOk()) {
			expect(result.value.isHealthy).toBe(false);
			expect(result.value.timestamp).toBe(staleTimestamp);
			expect(result.value.ageHours).toBeGreaterThan(47);
			expect(result.value.ageHours).toBeLessThan(49);
		}
	});

	it('should handle RGS endpoint returning non-200 status', async () => {
		(global.fetch as jest.Mock) = jest.fn(() =>
			Promise.resolve({
				ok: false,
				status: 404,
			}),
		);

		const result = await checkRgsHealth();

		expect(result.isErr()).toBe(true);
		if (result.isErr()) {
			expect(result.error.message).toContain('404');
		}
	});

	it('should handle missing timestamp in RGS HTML', async () => {
		const mockHtml = `
			<a href="some-file-without-timestamp.lngossip">snapshot</a>
		`;

		(global.fetch as jest.Mock) = jest.fn(() =>
			Promise.resolve({
				ok: true,
				text: () => Promise.resolve(mockHtml),
			}),
		);

		const result = await checkRgsHealth();

		expect(result.isErr()).toBe(true);
		if (result.isErr()) {
			expect(result.error.message).toContain('Could not parse');
		}
	});

	it('should handle network timeout', async () => {
		jest.useFakeTimers();

		(global.fetch as jest.Mock) = jest.fn(() =>
			new Promise(resolve => {
				setTimeout(() => resolve({
					ok: true,
					text: () => Promise.resolve('<html></html>'),
				}), 10000); // longer than 5s timeout
			}),
		);

		const healthPromise = checkRgsHealth();

		jest.advanceTimersByTime(6000);

		await expect(healthPromise).resolves.toMatchObject({
			isErr: expect.any(Function),
		});

		const result = await healthPromise;
		expect(result.isErr()).toBe(true);

		jest.useRealTimers();
	});

	it('should parse timestamp with colon delimiter', async () => {
		const testTimestamp = 1762462800; // Nov 6, 2025

		const mockHtml = `
			<a href="snapshot__calculated-at:${testTimestamp}__range:10800-scope.lngossip">snapshot</a>
		`;

		(global.fetch as jest.Mock) = jest.fn(() =>
			Promise.resolve({
				ok: true,
				text: () => Promise.resolve(mockHtml),
			}),
		);

		const result = await checkRgsHealth();

		expect(result.isOk()).toBe(true);
		if (result.isOk()) {
			expect(result.value.timestamp).toBe(testTimestamp);
		}
	});

	it('should parse timestamp with percent-encoded colon', async () => {
		const testTimestamp = 1762462800; // Nov 6, 2025

		const mockHtml = `
			<a href="snapshot__calculated-at%3A${testTimestamp}__range%3A10800-scope.lngossip">snapshot</a>
		`;

		(global.fetch as jest.Mock) = jest.fn(() =>
			Promise.resolve({
				ok: true,
				text: () => Promise.resolve(mockHtml),
			}),
		);

		const result = await checkRgsHealth();

		expect(result.isOk()).toBe(true);
		if (result.isOk()) {
			expect(result.value.timestamp).toBe(testTimestamp);
		}
	});
});