LdkDebug.tsx

import Clipboard from '@react-native-clipboard/clipboard';
import lm, { ldk } from '@synonymdev/react-native-ldk';
import React, { ReactElement, memo, useState } from 'react';
import { useTranslation } from 'react-i18next';
import {
	Alert,
	ScrollView,
	StyleSheet,
	TouchableOpacity,
	View,
} from 'react-native';
import Share from 'react-native-share';

import Dialog from '../../../components/Dialog';
import KeyboardAvoidingView from '../../../components/KeyboardAvoidingView';
import NavigationHeader from '../../../components/NavigationHeader';
import SafeAreaInset from '../../../components/SafeAreaInset';
import Button from '../../../components/buttons/Button';
import { useLightningBalance } from '../../../hooks/lightning';
import { useAppDispatch, useAppSelector } from '../../../hooks/redux';
import { useSheetRef } from '../../../sheets/SheetRefsProvider';
import { openChannelsSelector } from '../../../store/reselect/lightning';
import { settingsSelector } from '../../../store/reselect/settings';
import {
	selectedNetworkSelector,
	selectedWalletSelector,
} from '../../../store/reselect/wallet';
import { removeLightningPeer } from '../../../store/slices/lightning';
import { updateSettings } from '../../../store/slices/settings';
import {
	createLightningInvoice,
	savePeer,
} from '../../../store/utils/lightning';
import { TextInput, View as ThemedView } from '../../../styles/components';
import { BodyM, Caption13Up } from '../../../styles/text';
import {
	addPeer,
	getNodeId,
	payLightningInvoice,
	rebroadcastAllKnownTransactions,
	recoverOutputs,
	recoverOutputsFromForceClose,
	refreshLdk,
	removeUnusedPeers,
	setupLdk,
} from '../../../utils/lightning';
import { zipLogs } from '../../../utils/lightning/logs';
import { showToast } from '../../../utils/notifications';

const LdkDebug = (): ReactElement => {
	const { t } = useTranslation('lightning');
	const dispatch = useAppDispatch();
	const sheetRef = useSheetRef('forceTransfer');
	const [peer, setPeer] = useState('');
	const [txid, setTxid] = useState('');
	const [showDialog, setShowDialog] = useState(false);
	const [payingInvoice, setPayingInvoice] = useState(false);
	const [refreshingLdk, setRefreshingLdk] = useState(false);
	const [restartingLdk, setRestartingLdk] = useState(false);
	const [rebroadcastingLdk, setRebroadcastingLdk] = useState(false);
	const [spendingStuckOutputs, setSpendingStuckOutputs] = useState(false);
	const [settingConfirmedTx, setSettingConfirmedTx] = useState(false);
	const [runningComprehensiveDebug, setRunningComprehensiveDebug] =
		useState(false);

	const { localBalance, remoteBalance } = useLightningBalance();
	const selectedWallet = useAppSelector(selectedWalletSelector);
	const selectedNetwork = useAppSelector(selectedNetworkSelector);
	const openChannels = useAppSelector(openChannelsSelector);
	const settings = useAppSelector(settingsSelector);

	// Max Dust HTLC Exposure form state
	const [selectedType, setSelectedType] = useState<
		'fixed_limit' | 'fee_rate_multiplier' | null
	>(settings?.max_dust_htlc_exposure_type ?? null);
	const [exposureValue, setExposureValue] = useState<string>(
		settings?.max_dust_htlc_exposure?.toString() ?? '1000',
	);

	const onNodeId = async (): Promise<void> => {
		const nodeId = await getNodeId();
		if (nodeId.isErr()) {
			console.log(nodeId.error.message);
			return;
		}
		console.log(`Node ID: ${nodeId.value}`);
		Clipboard.setString(nodeId.value);
		showToast({
			type: 'success',
			title: 'Copied Node ID to Clipboard',
			description: nodeId.value,
		});
	};

	const onRefreshLdk = async (): Promise<void> => {
		setRefreshingLdk(true);
		await refreshLdk({ selectedWallet, selectedNetwork });
		setRefreshingLdk(false);
	};

	const onRestartLdk = async (): Promise<void> => {
		setRestartingLdk(true);
		const res = await setupLdk({ selectedWallet, selectedNetwork });
		if (res.isErr()) {
			showToast({
				type: 'error',
				title: t('wallet:ldk_start_error_title'),
				description: res.error.message,
			});
		}
		setRestartingLdk(false);
	};

	const onAddPeer = async (): Promise<void> => {
		if (!peer) {
			// Attempt to grab and set peer string from clipboard.
			const clipboardStr = await Clipboard.getString();
			setPeer(clipboardStr);
			return;
		}
		const addPeerRes = await addPeer({ peer, timeout: 5000 });
		if (addPeerRes.isErr()) {
			showToast({
				type: 'warning',
				title: t('error_add_title'),
				description: addPeerRes.error.message,
			});
			return;
		}
		const savePeerRes = savePeer({ selectedWallet, selectedNetwork, peer });
		if (savePeerRes.isErr()) {
			showToast({
				type: 'warning',
				title: t('error_save_title'),
				description: savePeerRes.error.message,
			});
			return;
		}
		showToast({
			type: 'success',
			title: savePeerRes.value,
			description: t('peer_saved'),
		});
	};

	const onListPeers = async (): Promise<void> => {
		const peers = await lm.getPeers();
		console.log({ peers });
	};

	const onDisconnectPeers = async (): Promise<void> => {
		const peers = await lm.getPeers();

		const promises = peers.map(({ pubKey, address, port }) => {
			const peerStr = `${pubKey}@${address}:${port}`;
			// Remove peer from local storage
			dispatch(
				removeLightningPeer({
					peer: peerStr,
					selectedWallet,
					selectedNetwork,
				}),
			);
			// Instruct LDK to disconnect from peer
			return lm.removePeer({ pubKey, address, port, timeout: 5000 });
		});

		const results = await Promise.all(promises);
		for (const result of results) {
			if (result.isOk()) {
				console.log('Disconnected from peer.');
			} else {
				console.error(`Failed to disconnect: ${result.error.message}`);
			}
		}
	};

	const onRemoveUnusedPeers = async (): Promise<void> => {
		const res = await removeUnusedPeers({ selectedWallet, selectedNetwork });
		if (res.isErr()) {
			showToast({
				type: 'warning',
				title: 'No unused peers removed',
				description: res.error.message,
			});
		} else {
			showToast({
				type: 'info',
				title: 'Removed unused peers',
				description: res.value,
			});
		}
	};

	const onExportFiles = async (): Promise<void> => {
		const result = await zipLogs({
			includeJson: true,
			includeBinaries: true,
		});
		if (result.isErr()) {
			showToast({
				type: 'warning',
				title: t('error_logs'),
				description: t('error_logs_description'),
			});
			return;
		}

		// Share the zip file
		await Share.open({
			type: 'application/zip',
			url: `file://${result.value}`,
			title: t('export_logs'),
		});

		setShowDialog(false);
	};

	const onCreateInvoice = async (amountSats = 100): Promise<void> => {
		const createPaymentRequest = await createLightningInvoice({
			amountSats,
			description: '',
			expiryDeltaSeconds: 99999,
			selectedNetwork,
			selectedWallet,
		});
		if (createPaymentRequest.isErr()) {
			showToast({
				type: 'warning',
				title: t('error_invoice'),
				description: createPaymentRequest.error.message,
			});
			return;
		}
		const { to_str } = createPaymentRequest.value;
		console.log(to_str);
		Clipboard.setString(to_str);
		showToast({
			type: 'success',
			title: t('invoice_copied'),
			description: to_str,
		});
	};

	const onRebroadcastLdkTxs = async (): Promise<void> => {
		setRebroadcastingLdk(true);
		await rebroadcastAllKnownTransactions();
		setRebroadcastingLdk(false);
	};

	const onSpendStuckOutputs = async (): Promise<void> => {
		setSpendingStuckOutputs(true);
		const res = await recoverOutputs();
		if (res.isOk()) {
			showToast({
				type: 'info',
				title: 'Stuck outputs recovered',
				description: res.value,
			});
		} else {
			showToast({
				type: 'warning',
				title: 'No stuck outputs recovered',
				description: res.error.message,
			});
		}
		setSpendingStuckOutputs(false);
	};

	const onForceCloseChannels = (): void => {
		sheetRef.current?.present();
	};

	const onSpendOutputsFromForceClose = async (): Promise<void> => {
		setSpendingStuckOutputs(true);
		const res = await recoverOutputsFromForceClose();
		if (res.isOk()) {
			showToast({
				type: 'info',
				title: 'Completed',
				description: res.value,
			});
		} else {
			showToast({
				type: 'warning',
				title: 'No stuck outputs recovered',
				description: res.error.message,
			});
		}
		setSpendingStuckOutputs(false);
	};

	const onPayInvoiceFromClipboard = async (): Promise<void> => {
		setPayingInvoice(true);
		const invoice = await Clipboard.getString();
		if (!invoice) {
			showToast({
				type: 'warning',
				title: 'No Invoice Detected',
				description: 'Unable to retrieve anything from the clipboard.',
			});
			setPayingInvoice(false);
			return;
		}
		const response = await payLightningInvoice({ invoice });
		if (response.isErr()) {
			showToast({
				type: 'warning',
				title: 'Invoice Payment Failed',
				description: response.error.message,
			});
			setPayingInvoice(false);
			return;
		}
		await refreshLdk({ selectedWallet, selectedNetwork });
		setPayingInvoice(false);
	};

	const onSetConfirmedTx = async (): Promise<void> => {
		if (!txid) {
			// Attempt to grab and set txid string from clipboard.
			const clipboardStr = await Clipboard.getString();
			setTxid(clipboardStr);
			return;
		}

		setSettingConfirmedTx(true);
		try {
			// Get network endpoint
			const baseUrl = 'https://mempool.space/api';

			// Fetch transaction details
			const txResponse = await fetch(`${baseUrl}/tx/${txid.trim()}`);
			if (!txResponse.ok) {
				showToast({
					type: 'error',
					title: 'Transaction Not Found',
					description: 'Unable to find transaction on mempool.space',
				});
				setSettingConfirmedTx(false);
				return;
			}

			const tx = await txResponse.json();

			// Check if transaction is confirmed
			if (!tx.status?.confirmed || !tx.status?.block_height) {
				showToast({
					type: 'error',
					title: 'Transaction Not Confirmed',
					description: 'Transaction is not yet confirmed on the blockchain',
				});
				setSettingConfirmedTx(false);
				return;
			}

			// Fetch transaction hex data
			const txHexResponse = await fetch(`${baseUrl}/tx/${txid.trim()}/hex`);
			if (!txHexResponse.ok) {
				showToast({
					type: 'error',
					title: 'Transaction Hex Error',
					description: 'Unable to fetch transaction hex data',
				});
				setSettingConfirmedTx(false);
				return;
			}

			const txHex = await txHexResponse.text();

			// Fetch block header
			const blockHash = tx.status.block_hash;
			const blockResponse = await fetch(`${baseUrl}/block/${blockHash}/header`);
			if (!blockResponse.ok) {
				showToast({
					type: 'error',
					title: 'Block Header Error',
					description: 'Unable to fetch block header',
				});
				setSettingConfirmedTx(false);
				return;
			}

			const blockHeader = await blockResponse.text();

			// Validate all required parameters
			if (!blockHeader) {
				showToast({
					type: 'error',
					title: 'Missing Block Header',
					description: 'Block header is empty or invalid',
				});
				setSettingConfirmedTx(false);
				return;
			}

			if (!txHex) {
				showToast({
					type: 'error',
					title: 'Missing Transaction Data',
					description: 'Transaction hex data is missing',
				});
				setSettingConfirmedTx(false);
				return;
			}

			if (!tx.status.block_height) {
				showToast({
					type: 'error',
					title: 'Missing Block Height',
					description: 'Block height is missing or invalid',
				});
				setSettingConfirmedTx(false);
				return;
			}

			// Call ldk.setTxConfirmed
			const setTxConfirmedRes = await ldk.setTxConfirmed({
				header: blockHeader,
				txData: [
					{
						transaction: txHex,
						pos: tx.status.block_time || 0, // Using block_time as position fallback
					},
				],
				height: tx.status.block_height,
			});

			if (setTxConfirmedRes.isErr()) {
				showToast({
					type: 'error',
					title: 'Set Confirmed Failed',
					description: setTxConfirmedRes.error.message,
				});
			} else {
				showToast({
					type: 'success',
					title: 'Transaction Confirmed',
					description: `Transaction ${txid.slice(0, 8)}... set as confirmed at height ${
						tx.status.block_height
					}`,
				});
			}
		} catch (error) {
			showToast({
				type: 'error',
				title: 'Error',
				description:
					error instanceof Error ? error.message : 'Unknown error occurred',
			});
		} finally {
			setSettingConfirmedTx(false);
		}
	};

	const sleep = (ms: number) =>
		new Promise((resolve) => setTimeout(resolve, ms));

	const onComprehensiveDebug = async (): Promise<void> => {
		Alert.alert(
			'Hard Refresh & Recovery',
			'This will perform a hard refresh of LDK and attempt to recover any stuck funds. This can take up to 2 minutes.\n\nPlease keep the app open on this screen until complete.',
			[
				{
					text: 'Cancel',
					style: 'cancel',
				},
				{
					text: 'Continue',
					onPress: async () => {
						setRunningComprehensiveDebug(true);
						let currentStep = '';

						try {
							// Step 1: Refresh LDK
							currentStep = 'Refreshing LDK';
							showToast({
								type: 'info',
								title: 'Step 1/5',
								description: currentStep,
							});
							await refreshLdk({ selectedWallet, selectedNetwork });

							await sleep(2000);

							// Step 2: Rebroadcast LDK Txs
							currentStep = 'Rebroadcasting LDK Transactions';
							showToast({
								type: 'info',
								title: 'Step 2/5',
								description: currentStep,
							});
							await rebroadcastAllKnownTransactions();

							await sleep(2000);

							// Step 3: Spend Stuck Outputs
							currentStep = 'Spending Stuck Outputs';
							showToast({
								type: 'info',
								title: 'Step 3/5',
								description: currentStep,
							});
							const stuckOutputsRes = await recoverOutputs();
							if (stuckOutputsRes.isOk()) {
								showToast({
									type: 'info',
									title: 'Stuck Outputs',
									description: stuckOutputsRes.value,
								});
							}

							await sleep(2000);

							// Step 4: Spend Outputs from Force Close
							currentStep = 'Spending Outputs from Force Close';
							showToast({
								type: 'info',
								title: 'Step 4/5',
								description: currentStep,
							});
							const forceCloseRes = await recoverOutputsFromForceClose();
							if (forceCloseRes.isOk()) {
								showToast({
									type: 'info',
									title: 'Force Close Outputs',
									description: forceCloseRes.value,
								});
							}

							await sleep(2000);

							// Step 5: Final Refresh LDK
							currentStep = 'Final LDK Refresh';
							showToast({
								type: 'info',
								title: 'Step 5/5',
								description: currentStep,
							});
							await refreshLdk({ selectedWallet, selectedNetwork });

							// Success
							showToast({
								type: 'success',
								title: 'Hard Refresh & Recovery Complete',
								description: 'All operations completed successfully',
							});
						} catch (error) {
							showToast({
								type: 'error',
								title: `Failed at: ${currentStep}`,
								description:
									error instanceof Error
										? error.message
										: 'Unknown error occurred',
							});
						} finally {
							setRunningComprehensiveDebug(false);
						}
					},
				},
			],
		);
	};

	return (
		<ThemedView style={styles.root}>
			<SafeAreaInset type="top" />
			<NavigationHeader title="LDK Debug" />
			<KeyboardAvoidingView style={styles.content}>
				<ScrollView contentContainerStyle={styles.scrollContent}>
					<Caption13Up color="secondary">Add Peer</Caption13Up>
					<TextInput
						style={styles.textInput}
						autoCapitalize="none"
						autoComplete="off"
						autoCorrect={false}
						autoFocus={false}
						value={peer}
						placeholder="publicKey@ip:port"
						multiline={true}
						blurOnSubmit
						returnKeyType="done"
						testID="AddPeerInput"
						onChangeText={setPeer}
					/>
					<Button
						style={styles.button}
						text={
							peer
								? 'Add Lightning Peer'
								: 'Paste Lightning Peer From Clipboard'
						}
						testID="AddPeerButton"
						onPress={onAddPeer}
					/>

					<Caption13Up style={styles.sectionTitle} color="secondary">
						Set Confirmed Transaction
					</Caption13Up>
					<TextInput
						style={styles.textInput}
						autoCapitalize="none"
						autoComplete="off"
						autoCorrect={false}
						autoFocus={false}
						value={txid}
						placeholder="Transaction ID"
						blurOnSubmit
						returnKeyType="done"
						testID="TxidInput"
						onChangeText={setTxid}
					/>
					<Button
						style={styles.button}
						text={
							txid ? 'Set Confirmed Tx' : 'Paste Transaction ID From Clipboard'
						}
						loading={settingConfirmedTx}
						testID="SetConfirmedTxButton"
						onPress={onSetConfirmedTx}
					/>

					<Caption13Up style={styles.sectionTitle} color="secondary">
						Debug
					</Caption13Up>
					<Button
						style={styles.button}
						text="Hard Refresh & Recovery"
						loading={runningComprehensiveDebug}
						testID="HardRefreshRecovery"
						onPress={onComprehensiveDebug}
					/>
					<Button
						style={styles.button}
						text="Get Node ID"
						testID="CopyNodeId"
						onPress={onNodeId}
					/>
					<Button
						style={styles.button}
						text="Refresh LDK"
						loading={refreshingLdk}
						testID="RefreshLDK"
						onPress={onRefreshLdk}
					/>
					<Button
						style={styles.button}
						text="Restart LDK"
						loading={restartingLdk}
						testID="RestartLDK"
						onPress={onRestartLdk}
					/>
					<Button
						style={styles.button}
						text="List Peers"
						onPress={onListPeers}
					/>
					<Button
						style={styles.button}
						text="Disconnect Peers"
						onPress={onDisconnectPeers}
					/>
					<Button
						style={styles.button}
						text="Remove Unused Peers"
						onPress={onRemoveUnusedPeers}
					/>
					<Button
						style={styles.button}
						text="Rebroadcast LDK Txs"
						loading={rebroadcastingLdk}
						testID="RebroadcastLDKTXS"
						onPress={onRebroadcastLdkTxs}
					/>
					<Button
						style={styles.button}
						text="Spend Stuck Outputs"
						loading={spendingStuckOutputs}
						onPress={onSpendStuckOutputs}
					/>
					<Button
						style={styles.button}
						text="Force Close Channels"
						onPress={onForceCloseChannels}
					/>
					<Button
						style={styles.button}
						text="Spend outputs from force close"
						loading={spendingStuckOutputs}
						onPress={onSpendOutputsFromForceClose}
					/>
					<Button
						style={styles.button}
						text="Export Files"
						onPress={(): void => setShowDialog(true)}
					/>

					{openChannels.length > 0 && (
						<>
							<Button
								style={styles.button}
								text="Create Invoice: 100 sats"
								disabled={remoteBalance < 100}
								onPress={() => onCreateInvoice(100)}
							/>
							<Button
								style={styles.button}
								text="Create Invoice: 5000 sats"
								disabled={remoteBalance < 5000}
								onPress={() => onCreateInvoice(5000)}
							/>
							<Button
								style={styles.button}
								text="Pay Invoice From Clipboard"
								loading={payingInvoice}
								disabled={localBalance <= 0}
								onPress={onPayInvoiceFromClipboard}
							/>
						</>
					)}

					<Caption13Up style={styles.sectionTitle} color="secondary">
						Max Dust HTLC Exposure
					</Caption13Up>

					{/* Radio buttons for type selection */}
					<TouchableOpacity
						style={styles.radioOption}
						onPress={() =>
							setSelectedType(
								selectedType === 'fixed_limit' ? null : 'fixed_limit',
							)
						}>
						<View
							style={[
								styles.radioButton,
								selectedType === 'fixed_limit' && styles.radioButtonSelected,
							]}
						/>
						<BodyM style={styles.radioLabel}>Fixed Limit (msats)</BodyM>
					</TouchableOpacity>

					<TouchableOpacity
						style={styles.radioOption}
						onPress={() =>
							setSelectedType(
								selectedType === 'fee_rate_multiplier'
									? null
									: 'fee_rate_multiplier',
							)
						}>
						<View
							style={[
								styles.radioButton,
								selectedType === 'fee_rate_multiplier' &&
									styles.radioButtonSelected,
							]}
						/>
						<BodyM style={styles.radioLabel}>Fee Rate Multiplier</BodyM>
					</TouchableOpacity>

					{/* Number input - only show when a type is selected */}
					{selectedType && (
						<TextInput
							style={styles.textInput}
							value={exposureValue}
							onChangeText={setExposureValue}
							placeholder={selectedType === 'fixed_limit' ? '1000' : '10'}
							keyboardType="numeric"
							autoCapitalize="none"
							autoComplete="off"
							autoCorrect={false}
						/>
					)}

					{/* Action buttons */}
					<View style={styles.buttonRow}>
						<Button
							style={[styles.button, styles.buttonHalf]}
							text="Set max dust"
							disabled={!selectedType || !exposureValue}
							onPress={(): void => {
								const numValue = Number.parseInt(exposureValue, 10);
								if (!Number.isNaN(numValue) && selectedType) {
									dispatch(
										updateSettings({
											max_dust_htlc_exposure_type: selectedType,
											max_dust_htlc_exposure: numValue,
										}),
									);
								}
							}}
						/>
						{(settings?.max_dust_htlc_exposure_type ||
							settings?.max_dust_htlc_exposure) && (
							<Button
								style={[styles.button, styles.buttonHalf]}
								text="Reset max dust"
								onPress={(): void => {
									setSelectedType(null);
									setExposureValue('1000');
									dispatch(
										updateSettings({
											max_dust_htlc_exposure_type: undefined,
											max_dust_htlc_exposure: undefined,
										}),
									);
								}}
							/>
						)}
					</View>

					<SafeAreaInset type="bottom" minPadding={16} />
				</ScrollView>
			</KeyboardAvoidingView>

			<Dialog
				visible={showDialog}
				title="Export sensitive files?"
				description="This export contains sensitive data and gives control over your Lightning funds. Do you want to continue?"
				cancelText="Cancel"
				onCancel={(): void => setShowDialog(false)}
				onConfirm={onExportFiles}
			/>
		</ThemedView>
	);
};

const styles = StyleSheet.create({
	root: {
		flex: 1,
	},
	content: {
		flex: 1,
	},
	scrollContent: {
		flexGrow: 1,
		paddingHorizontal: 16,
	},
	sectionTitle: {
		marginTop: 32,
	},
	textInput: {
		width: '100%',
		minHeight: 50,
		borderRadius: 10,
		padding: 10,
		textAlign: 'left',
		alignItems: 'center',
		justifyContent: 'center',
		fontWeight: 'bold',
		fontSize: 16,
		marginTop: 8,
	},
	button: {
		marginTop: 8,
	},
	radioOption: {
		flexDirection: 'row',
		alignItems: 'center',
		marginTop: 12,
	},
	radioButton: {
		width: 20,
		height: 20,
		borderRadius: 10,
		borderWidth: 2,
		borderColor: '#666',
		marginRight: 12,
	},
	radioButtonSelected: {
		borderColor: '#FF6600',
		backgroundColor: '#FF6600',
	},
	radioLabel: {
		flex: 1,
	},
	buttonRow: {
		flexDirection: 'row',
		marginTop: 16,
		gap: 8,
	},
	buttonHalf: {
		flex: 1,
		marginTop: 0,
	},
});

export default memo(LdkDebug);