Merge pull request #139 from synonymdev/stale-backup-recovery

Option to force close channels on startup

Author: Jasonvdb

example/App.tsx

@@ -30,7 +30,11 @@ import lm, {
 	TChannelUpdate,
 } from '@synonymdev/react-native-ldk';
 import { peers } from './utils/constants';
-import { createNewAccount, getAddress } from './utils/helpers';
+import {
+	createNewAccount,
+	getAddress,
+	simulateStaleRestore,
+} from './utils/helpers';
 import RNFS from 'react-native-fs';
 
 let logSubscription: EmitterSubscription | undefined;
@@ -615,6 +619,17 @@ const App = (): ReactElement => {
 							);
 						}}
 					/>
+					<Button
+						title={'Simulate stale backup restore'}
+						onPress={async (): Promise<void> => {
+							try {
+								await simulateStaleRestore((msg) => setMessage(msg));
+							} catch (e) {
+								setMessage(e.message);
+								return;
+							}
+						}}
+					/>
 					<Button
 						title={'Restart node'}
 						onPress={async (): Promise<void> => {

example/ios/Podfile.lock

@@ -302,7 +302,7 @@ PODS:
   - React-jsinspector (0.70.6)
   - React-logger (0.70.6):
     - glog
-  - react-native-ldk (0.0.98):
+  - react-native-ldk (0.0.99):
     - React
   - react-native-randombytes (3.6.1):
     - React-Core
@@ -593,7 +593,7 @@ SPEC CHECKSUMS:
   React-jsiexecutor: b4a65947391c658450151275aa406f2b8263178f
   React-jsinspector: 60769e5a0a6d4b32294a2456077f59d0266f9a8b
   React-logger: 1623c216abaa88974afce404dc8f479406bbc3a0
-  react-native-ldk: 0b2b9c3e57c80b19d94ec306f49765b29530758e
+  react-native-ldk: 175104646d32a4f52d82299c6981ad4bf91ad603
   react-native-randombytes: 421f1c7d48c0af8dbcd471b0324393ebf8fe7846
   react-native-tcp-socket: c1b7297619616b4c9caae6889bcb0aba78086989
   React-perflogger: 8c79399b0500a30ee8152d0f9f11beae7fc36595

example/ldk/index.ts

@@ -95,7 +95,9 @@ export const syncLdk = async (): Promise<Result<string>> => {
  * 3. Adds/Connects saved peers from storage. (Note: Not needed as LDK handles this automatically once a peer has been added successfully. Only used to make example app easier to test.)
  * 4. Syncs LDK.
  */
-export const setupLdk = async (): Promise<Result<string>> => {
+export const setupLdk = async (
+	forceCloseAllChannels = false,
+): Promise<Result<string>> => {
 	try {
 		await ldk.stop();
 		const account = await getAccount();
@@ -121,6 +123,9 @@ export const setupLdk = async (): Promise<Result<string>> => {
 			getTransactionPosition,
 			broadcastTransaction,
 			network: ldkNetwork(selectedNetwork),
+			forceCloseOnStartup: forceCloseAllChannels
+				? { forceClose: true, broadcastLatestTx: false }
+				: undefined,
 		});
 
 		if (lmStart.isErr()) {
@@ -323,6 +328,7 @@ export const backupAccount = async (
  */
 export const importAccount = async (
 	backup: string | TAccountBackup,
+	forceCloseAllChannels = false,
 ): Promise<Result<TAccount>> => {
 	const importResponse = await lm.importAccount({
 		backup,
@@ -333,7 +339,7 @@ export const importAccount = async (
 	}
 	await setAccount(importResponse.value);
 	await setItem(EAccount.currentAccountKey, importResponse.value.name);
-	await setupLdk();
+	await setupLdk(forceCloseAllChannels);
 	await syncLdk();
 	return ok(importResponse.value);
 };

example/utils/helpers.ts

@@ -1,6 +1,10 @@
 import Keychain from 'react-native-keychain';
-import { TAccount, TAvailableNetworks } from '@synonymdev/react-native-ldk';
-import { getItem, setItem } from '../ldk';
+import {
+	EEventTypes,
+	TAccount,
+	TAvailableNetworks,
+} from '@synonymdev/react-native-ldk';
+import { backupAccount, getItem, importAccount, setItem } from '../ldk';
 import { EAccount } from './types';
 import { err, ok, Result } from './result';
 import { randomBytes } from 'react-native-randombytes';
@@ -10,6 +14,8 @@ import RNFS from 'react-native-fs';
 import * as bip32 from 'bip32';
 import * as bip39 from 'bip39';
 import { ENetworks } from '@synonymdev/react-native-ldk/dist/utils/types';
+import ldk from '@synonymdev/react-native-ldk/dist/ldk';
+import Clipboard from '@react-native-clipboard/clipboard';
 
 /**
  * Use Keychain to save LDK name & seed.
@@ -205,3 +211,78 @@ export const ldkNetwork = (network: TAvailableNetworks): ENetworks => {
 			return ENetworks.mainnet;
 	}
 };
+
+export const simulateStaleRestore = async (
+	onUpdate: (string) => void,
+): Promise<void> => {
+	const channels = await ldk.listChannels();
+	if (channels.isErr()) {
+		throw channels.error;
+	}
+	if (channels.value.filter((c) => c.is_usable).length === 0) {
+		throw new Error('No usable channels. Open a channel first.');
+	}
+
+	onUpdate('Backing up...');
+	const backupResponse = await backupAccount();
+	if (backupResponse.isErr()) {
+		throw backupResponse.error;
+	}
+
+	const timeoutSeconds = 30;
+	const invoice = await ldk.createPaymentRequest({
+		amountSats: 12,
+		description: 'crash test',
+		expiryDeltaSeconds: timeoutSeconds,
+	});
+	if (invoice.isErr()) {
+		throw invoice.error;
+	}
+
+	let paymentClaimed = false;
+	let paymentSubscription = ldk.onEvent(
+		EEventTypes.channel_manager_payment_claimed,
+		() => (paymentClaimed = true),
+	);
+
+	Clipboard.setString(invoice.value.to_str);
+
+	//Keep checking if we got the payment
+	for (let i = 0; i < timeoutSeconds; i++) {
+		onUpdate(
+			`Please pay invoice in clipboard to continue (${timeoutSeconds - i})...`,
+		);
+
+		if (paymentClaimed) {
+			onUpdate('Payment claimed! Testing stale restore...');
+			break;
+		}
+
+		await new Promise((resolve) => setTimeout(resolve, 1000));
+	}
+
+	paymentSubscription.remove();
+
+	if (!paymentClaimed) {
+		throw new Error('No payment claimed. Timeout out.');
+	}
+
+	onUpdate('Importing stale backup and force closing all channels...');
+
+	await new Promise((resolve) => setTimeout(resolve, 2500));
+
+	await ldk.stop();
+	const forceCloseAllChannels = true; //To test the crash restore set to false
+	const importResponse = await importAccount(
+		backupResponse.value,
+		forceCloseAllChannels,
+	);
+	if (importResponse.isErr()) {
+		throw importResponse.error;
+	}
+
+	await new Promise((resolve) => setTimeout(resolve, 2500));
+	onUpdate(
+		"If this didn't crash and you can see your claimable balance, you're good!",
+	);
+};

lib/android/src/main/java/com/reactnativeldk/LdkModule.kt

@@ -612,6 +612,19 @@ class LdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMod
         handleResolve(promise, LdkCallbackResponses.close_channel_success)
     }
 
+    @ReactMethod
+    fun forceCloseAllChannels(broadcastLatestTx: Boolean, promise: Promise) {
+        channelManager ?: return handleReject(promise, LdkErrors.init_channel_manager)
+
+        if (broadcastLatestTx) {
+            channelManager!!.force_close_all_channels_broadcasting_latest_txn()
+        } else {
+            channelManager!!.force_close_all_channels_without_broadcasting_txn()
+        }
+
+        handleResolve(promise, LdkCallbackResponses.close_channel_success)
+    }
+
     @ReactMethod
     fun spendOutputs(descriptorsSerialized: ReadableArray, outputs: ReadableArray, changeDestinationScript: String, feeRate: Double, promise: Promise) {
         keysManager ?: return handleReject(promise, LdkErrors.init_keys_manager)

lib/ios/Ldk.m

@@ -69,6 +69,9 @@ @interface RCT_EXTERN_MODULE(Ldk, NSObject)
                   force:(BOOL *)force
                   resolve:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(forceCloseAllChannels:(BOOL *)broadcastLatestTx
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(spendOutputs:(NSArray *)descriptorsSerialized
                   outputs:(NSArray *)outputs
                   changeDestinationScript:(NSString *)changeDestinationScript

lib/ios/Ldk.swift

@@ -654,6 +654,21 @@ class Ldk: NSObject {
         return handleResolve(resolve, .close_channel_success)
     }
 
+    @objc
+    func forceCloseAllChannels(_ broadcastLatestTx: Bool, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        guard let channelManager = channelManager else {
+            return handleReject(reject, .init_channel_manager)
+        }
+        
+        if broadcastLatestTx {
+            channelManager.forceCloseAllChannelsBroadcastingLatestTxn()
+        } else {
+            channelManager.forceCloseAllChannelsWithoutBroadcastingTxn()
+        }
+        
+        return handleResolve(resolve, .close_channel_success)
+    }
+    
     @objc
     func spendOutputs(_ descriptorsSerialized: NSArray, outputs: NSArray, changeDestinationScript: NSString, feeRate: NSInteger, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
         guard let keysManager = keysManager else {

lib/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@synonymdev/react-native-ldk",
   "title": "React Native LDK",
-  "version": "0.0.98",
+  "version": "0.0.99",
   "description": "React Native wrapper for LDK",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

lib/src/ldk.ts

@@ -436,6 +436,24 @@ class LDK {
 		}
 	}
 
+	/**
+	 * Force close all channels
+	 * @param broadcastLatestTx
+	 * @returns {Promise<Err<unknown> | Ok<Ok<string> | Err<string>>>}
+	 */
+	async forceCloseAllChannels(
+		broadcastLatestTx: boolean,
+	): Promise<Result<string>> {
+		try {
+			const res = await NativeLDK.forceCloseAllChannels(broadcastLatestTx);
+			this.writeDebugToLog('forceCloseAllChannels');
+			return ok(res);
+		} catch (e) {
+			this.writeErrorToLog('forceCloseAllChannels', e);
+			return err(e);
+		}
+	}
+
 	/**
 	 * Use LDK key manager to spend spendable outputs
 	 * https://docs.rs/lightning/latest/lightning/chain/keysinterface/struct.KeysManager.html#method.spend_spendable_outputs

lib/src/lightning-manager.ts

@@ -245,6 +245,7 @@ class LightningManager {
 		broadcastTransaction,
 		network,
 		rapidGossipSyncUrl = 'https://rapidsync.lightningdevkit.org/snapshot/',
+		forceCloseOnStartup,
 		userConfig = defaultUserConfig,
 	}: TLdkStart): Promise<Result<string>> {
 		if (!account) {
@@ -426,6 +427,11 @@ class LightningManager {
 		// Set fee estimates
 		await this.setFees();
 
+		//Force close all channels on startup. Likely to recover funds after restoring from a stale backup.
+		if (forceCloseOnStartup && forceCloseOnStartup.forceClose) {
+			await ldk.forceCloseAllChannels(forceCloseOnStartup.broadcastLatestTx);
+		}
+
 		// Add cached peers
 		await this.addPeers();