diff --git a/android/app/src/main/java/com/blixtwallet/LndMobileTools.java b/android/app/src/main/java/com/blixtwallet/LndMobileTools.java
index 114818830..c18113779 100644
--- a/android/app/src/main/java/com/blixtwallet/LndMobileTools.java
+++ b/android/app/src/main/java/com/blixtwallet/LndMobileTools.java
@@ -7,6 +7,7 @@
 import android.Manifest;
 import android.app.ActivityManager;
 import android.database.sqlite.SQLiteDatabase;
+import android.net.Uri;
 import android.os.FileObserver;
 import android.os.Process;
 import android.util.Base64;
@@ -765,6 +766,56 @@ public void generateSecureRandomAsBase64(int length, Promise promise) {
     promise.resolve(Base64.encodeToString(buffer, Base64.NO_WRAP));
   }
 
+  @ReactMethod
+  public void saveChannelDbFile(Promise promise) {
+    // This promise will be resolved in MainActivity
+    MainActivity.tmpExportChannelDbPromise = promise;
+    Intent intent = new Intent(Intent.ACTION_CREATE_DOCUMENT);
+    intent.addCategory(Intent.CATEGORY_OPENABLE);
+    intent.setType("application/octet-stream");
+    intent.putExtra(Intent.EXTRA_TITLE, "channel.db");
+    getReactApplicationContext().getCurrentActivity().startActivityForResult(intent, MainActivity.INTENT_EXPORTCHANNELDBFILE);
+  }
+
+  @ReactMethod
+  public void importChannelDbFile(String channelDbImportPath, Promise promise) {
+    Log.i(TAG, getReactApplicationContext().getFilesDir().toString() + "/data/graph/" + BuildConfig.CHAIN + "/channel.db");
+    try {
+      File sourceFile = new File(channelDbImportPath);
+
+      String channelDbFilePath = getReactApplicationContext().getFilesDir().toString() + "/data/graph/" + BuildConfig.CHAIN + "/channel.db";
+      File destChannelDbFile = new File(channelDbFilePath);
+
+      // Delete the channel.db file first if there is one
+      destChannelDbFile.delete();
+
+      File destFile = new File(channelDbFilePath);
+      if (!destFile.exists() && !destFile.createNewFile()) {
+        promise.reject(new IOException("Failed to create destination channel.db file"));
+        return;
+      }
+
+      // Copy content
+      InputStream in = new FileInputStream(sourceFile);
+      OutputStream out = new FileOutputStream(destFile);
+      byte[] buffer = new byte[1024];
+      int read;
+      while ((read = in.read(buffer)) != -1) {
+        out.write(buffer, 0, read);
+      }
+      in.close();
+      out.flush();
+      out.close();
+
+      // Delete the cached file
+      sourceFile.delete();
+
+      promise.resolve(true);
+    } catch (IOException error) {
+      promise.reject(error);
+    }
+  }
+
   private void checkWriteExternalStoragePermission(@NonNull RequestWriteExternalStoragePermissionCallback successCallback,
                                                    @NonNull Runnable failCallback,
                                                    @NonNull Runnable failPermissionCheckcallback) {
diff --git a/android/app/src/main/java/com/blixtwallet/MainActivity.kt b/android/app/src/main/java/com/blixtwallet/MainActivity.kt
index 96a0f706a..82f252f39 100644
--- a/android/app/src/main/java/com/blixtwallet/MainActivity.kt
+++ b/android/app/src/main/java/com/blixtwallet/MainActivity.kt
@@ -5,6 +5,7 @@ import android.os.Bundle
 import android.widget.Toast
 import com.facebook.react.ReactActivity
 import com.facebook.react.ReactActivityDelegate
+import com.facebook.react.bridge.Promise
 import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint.fabricEnabled
 import com.facebook.react.defaults.DefaultReactActivityDelegate
 import dev.doubledot.doki.ui.DokiActivity
@@ -92,6 +93,29 @@ class MainActivity : ReactActivity() {
             } catch (e: IOException) {
                 Toast.makeText(this, "Error " + e.message, Toast.LENGTH_LONG).show()
             }
+        } else if (requestCode == INTENT_EXPORTCHANNELDBFILE && resultCode == RESULT_OK) {
+            val destUri = data!!.data
+            val sourceLocation = File(filesDir.toString() + "/data/graph/" + BuildConfig.CHAIN + "/channel.db")
+            try {
+                val `in`: InputStream = FileInputStream(sourceLocation)
+                val out = contentResolver.openOutputStream(destUri!!)
+                val buf = ByteArray(1024)
+                var len: Int
+                while (`in`.read(buf).also { len = it } > 0) {
+                    out!!.write(buf, 0, len)
+                }
+                `in`.close()
+                out!!.close()
+
+                if (tmpExportChannelDbPromise != null) {
+                    tmpExportChannelDbPromise!!.resolve(true)
+                } else {
+                    Toast.makeText(this, "promise is null", Toast.LENGTH_LONG).show()
+                }
+            } catch (e: IOException) {
+                Toast.makeText(this, "Error " + e.message, Toast.LENGTH_LONG).show()
+                tmpExportChannelDbPromise!!.reject(e)
+            }
         }
     }
 
@@ -111,14 +135,19 @@ class MainActivity : ReactActivity() {
         @JvmField
         var INTENT_EXPORTCHANBACKUP = 101
         @JvmField
+        var tmpChanBackup: ByteArray = ByteArray(0)
+        @JvmField
         var INTENT_EXPORTCHANBACKUPFILE = 102
         @JvmField
         var INTENT_COPYSPEEDLOADERLOG = 103
         @JvmField
-        var tmpChanBackup: ByteArray = ByteArray(0)
+        var INTENT_EXPORTCHANNELDBFILE = 104
+        @JvmField
+        var tmpExportChannelDbPromise: Promise? = null
+        @JvmField
         var currentActivity: WeakReference<MainActivity>? = null
         @JvmStatic
         val activity: MainActivity?
             get() = currentActivity!!.get()
     }
-}
+}
\ No newline at end of file
diff --git a/ios/LndMobile/Lnd.swift b/ios/LndMobile/Lnd.swift
index 943cbf509..f9f749278 100644
--- a/ios/LndMobile/Lnd.swift
+++ b/ios/LndMobile/Lnd.swift
@@ -122,6 +122,7 @@ open class Lnd {
     "VerifyMessage": { bytes, cb in LndmobileVerifyMessage(bytes, cb) },
     "SignMessage": { bytes, cb in LndmobileSignMessage(bytes, cb) },
     "SignerSignMessage": { bytes, cb in LndmobileSignerSignMessage(bytes, cb) },
+    "RestoreChannelBackups": { bytes, cb in LndmobileRestoreChannelBackups(bytes, cb) },
 
     // autopilot
     "AutopilotStatus": { bytes, cb in LndmobileAutopilotStatus(bytes, cb) },
diff --git a/src/Main.tsx b/src/Main.tsx
index d1e11f4b1..6357508ff 100644
--- a/src/Main.tsx
+++ b/src/Main.tsx
@@ -1,6 +1,6 @@
 import React, { useEffect, useState } from "react";
 import { StatusBar, Alert, NativeModules } from "react-native";
-import { Spinner, H1, H2 } from "native-base";
+import { Spinner, H1, H2, Text } from "native-base";
 import {
   createStackNavigator,
   CardStyleInterpolators,
@@ -40,6 +40,7 @@ import useStackNavigationOptions from "./hooks/useStackNavigationOptions";
 import { navigator } from "./utils/navigation";
 import { PLATFORM } from "./utils/constants";
 import Prompt, { IPromptNavigationProps } from "./windows/HelperWindows/Prompt";
+import { isInstanceBricked } from "./storage/app";
 
 const RootStack = createStackNavigator();
 
@@ -86,6 +87,7 @@ export default function Main() {
   const appReady = useStoreState((store) => store.appReady);
   const lightningReady = useStoreState((store) => store.lightning.ready);
   const walletCreated = useStoreState((store) => store.walletCreated);
+  const importChannelDbOnStartup = useStoreState((store) => store.importChannelDbOnStartup);
   const loggedIn = useStoreState((store) => store.security.loggedIn);
   const initializeApp = useStoreActions((store) => store.initializeApp);
   const [initialRoute, setInitialRoute] = useState("Loading");
@@ -95,13 +97,22 @@ export default function Main() {
     (store) => store.settings.screenTransitionsEnabled,
   );
 
-  const [state, setState] = useState<"init" | "authentication" | "onboarding" | "started">("init");
+  console.log("walletCreated", walletCreated);
+
+  const [state, setState] = useState<
+    "init" | "authentication" | "onboarding" | "started" | "bricked"
+  >("init");
 
   useEffect(() => {
     // tslint:disable-next-line
     (async () => {
       if (!appReady) {
         try {
+          if (await isInstanceBricked()) {
+            setState("bricked");
+            return;
+          }
+
           await initializeApp();
         } catch (e) {
           toast(e.message, 0, "danger");
@@ -120,7 +131,7 @@ export default function Main() {
         setState("authentication");
       } else if (!lightningReady) {
         setState("started");
-        if (!walletCreated) {
+        if (!walletCreated && !importChannelDbOnStartup) {
           setInitialRoute("Welcome");
         } else {
           // try {
@@ -225,6 +236,10 @@ export default function Main() {
     return <Authentication />;
   }
 
+  if (state === "bricked") {
+    return <Text>Bricked</Text>;
+  }
+
   return (
     <RootStack.Navigator initialRouteName={initialRoute} screenOptions={screenOptions}>
       <RootStack.Screen
diff --git a/src/lndmobile/LndMobile.d.ts b/src/lndmobile/LndMobile.d.ts
index c335799ce..c1284d810 100644
--- a/src/lndmobile/LndMobile.d.ts
+++ b/src/lndmobile/LndMobile.d.ts
@@ -54,6 +54,8 @@ export interface ILndMobileTools {
   DEBUG_deleteSpeedloaderDgraphDirectory(): null;
   DEBUG_deleteNeutrinoFiles(): boolean;
   getInternalFiles(): Promise<Record<string, number>>;
+  saveChannelDbFile(): Promise<boolean>;
+  importChannelDbFile(channelDbPath: string): Promise<boolean>;
 
   // Android-specific
   getIntentStringData(): Promise<string | null>;
diff --git a/src/lndmobile/wallet.ts b/src/lndmobile/wallet.ts
index 7f289cb04..8e701c0f2 100644
--- a/src/lndmobile/wallet.ts
+++ b/src/lndmobile/wallet.ts
@@ -9,7 +9,11 @@ import { lnrpc, signrpc } from "../../proto/lightning";
  * TODO test
  */
 export const genSeed = async (passphrase: string | undefined): Promise<lnrpc.GenSeedResponse> => {
-  const response = await sendCommand<lnrpc.IGenSeedRequest, lnrpc.GenSeedRequest, lnrpc.GenSeedResponse>({
+  const response = await sendCommand<
+    lnrpc.IGenSeedRequest,
+    lnrpc.GenSeedRequest,
+    lnrpc.GenSeedResponse
+  >({
     request: lnrpc.GenSeedRequest,
     response: lnrpc.GenSeedResponse,
     method: "GenSeed",
@@ -40,15 +44,19 @@ export const initWallet = async (
     options.channelBackups = {
       multiChanBackup: {
         multiChanBackup: base64.toByteArray(channelBackupsBase64),
-      }
-    }
+      },
+    };
   }
 
-  const response = await sendCommand<lnrpc.IInitWalletRequest, lnrpc.InitWalletRequest, lnrpc.InitWalletResponse>({
+  const response = await sendCommand<
+    lnrpc.IInitWalletRequest,
+    lnrpc.InitWalletRequest,
+    lnrpc.InitWalletResponse
+  >({
     request: lnrpc.InitWalletRequest,
     response: lnrpc.InitWalletResponse,
     method: "InitWallet",
-    options
+    options,
   });
   return response;
 };
@@ -59,7 +67,11 @@ export const initWallet = async (
 export const unlockWallet = async (password: string): Promise<lnrpc.UnlockWalletResponse> => {
   const start = new Date().getTime();
   // await NativeModules.LndMobile.unlockWallet(password);
-  const response = await sendCommand<lnrpc.IUnlockWalletRequest, lnrpc.UnlockWalletRequest, lnrpc.UnlockWalletResponse>({
+  const response = await sendCommand<
+    lnrpc.IUnlockWalletRequest,
+    lnrpc.UnlockWalletRequest,
+    lnrpc.UnlockWalletResponse
+  >({
     request: lnrpc.UnlockWalletRequest,
     response: lnrpc.UnlockWalletResponse,
     method: "UnlockWallet",
@@ -74,8 +86,15 @@ export const unlockWallet = async (password: string): Promise<lnrpc.UnlockWallet
 /**
  * @throws
  */
-export const deriveKey = async (keyFamily: number, keyIndex: number): Promise<signrpc.KeyDescriptor> => {
-  const response = await sendCommand<signrpc.IKeyLocator, signrpc.KeyLocator, signrpc.KeyDescriptor>({
+export const deriveKey = async (
+  keyFamily: number,
+  keyIndex: number,
+): Promise<signrpc.KeyDescriptor> => {
+  const response = await sendCommand<
+    signrpc.IKeyLocator,
+    signrpc.KeyLocator,
+    signrpc.KeyDescriptor
+  >({
     request: signrpc.KeyLocator,
     response: signrpc.KeyDescriptor,
     method: "WalletKitDeriveKey",
@@ -90,8 +109,15 @@ export const deriveKey = async (keyFamily: number, keyIndex: number): Promise<si
 /**
  * @throws
  */
-export const derivePrivateKey = async (keyFamily: number, keyIndex: number): Promise<signrpc.KeyDescriptor> => {
-  const response = await sendCommand<signrpc.IKeyDescriptor, signrpc.KeyDescriptor, signrpc.KeyDescriptor>({
+export const derivePrivateKey = async (
+  keyFamily: number,
+  keyIndex: number,
+): Promise<signrpc.KeyDescriptor> => {
+  const response = await sendCommand<
+    signrpc.IKeyDescriptor,
+    signrpc.KeyDescriptor,
+    signrpc.KeyDescriptor
+  >({
     request: signrpc.KeyDescriptor,
     response: signrpc.KeyDescriptor,
     method: "WalletKitDerivePrivateKey",
@@ -108,8 +134,15 @@ export const derivePrivateKey = async (keyFamily: number, keyIndex: number): Pro
 /**
  * @throws
  */
-export const verifyMessageNodePubkey = async (signature: string, msg: Uint8Array): Promise<lnrpc.VerifyMessageResponse> => {
-  const response = await sendCommand<lnrpc.IVerifyMessageRequest, lnrpc.VerifyMessageRequest, lnrpc.VerifyMessageResponse>({
+export const verifyMessageNodePubkey = async (
+  signature: string,
+  msg: Uint8Array,
+): Promise<lnrpc.VerifyMessageResponse> => {
+  const response = await sendCommand<
+    lnrpc.IVerifyMessageRequest,
+    lnrpc.VerifyMessageRequest,
+    lnrpc.VerifyMessageResponse
+  >({
     request: lnrpc.VerifyMessageRequest,
     response: lnrpc.VerifyMessageResponse,
     method: "VerifyMessage",
@@ -124,8 +157,14 @@ export const verifyMessageNodePubkey = async (signature: string, msg: Uint8Array
 /**
  * @throws
  */
-export const signMessageNodePubkey = async (msg: Uint8Array): Promise<lnrpc.SignMessageResponse> => {
-  const response = await sendCommand<lnrpc.ISignMessageRequest, lnrpc.SignMessageRequest, lnrpc.SignMessageResponse>({
+export const signMessageNodePubkey = async (
+  msg: Uint8Array,
+): Promise<lnrpc.SignMessageResponse> => {
+  const response = await sendCommand<
+    lnrpc.ISignMessageRequest,
+    lnrpc.SignMessageRequest,
+    lnrpc.SignMessageResponse
+  >({
     request: lnrpc.SignMessageRequest,
     response: lnrpc.SignMessageResponse,
     method: "SignMessage",
@@ -139,8 +178,16 @@ export const signMessageNodePubkey = async (msg: Uint8Array): Promise<lnrpc.Sign
 /**
  * @throws
  */
-export const signMessage = async (keyFamily: number, keyIndex: number, msg: Uint8Array): Promise<signrpc.SignMessageResp> => {
-  const response = await sendCommand<signrpc.ISignMessageReq, signrpc.SignMessageReq, signrpc.SignMessageResp>({
+export const signMessage = async (
+  keyFamily: number,
+  keyIndex: number,
+  msg: Uint8Array,
+): Promise<signrpc.SignMessageResp> => {
+  const response = await sendCommand<
+    signrpc.ISignMessageReq,
+    signrpc.SignMessageReq,
+    signrpc.SignMessageResp
+  >({
     request: signrpc.SignMessageReq,
     response: signrpc.SignMessageResp,
     method: "SignerSignMessage",
@@ -156,17 +203,43 @@ export const signMessage = async (keyFamily: number, keyIndex: number, msg: Uint
   return response;
 };
 
+/**
+ * @throws
+ */
+export const restoreChannelBackups = async (
+  channelsBackupBase64: string,
+): Promise<lnrpc.RestoreBackupResponse> => {
+  const response = await sendCommand<
+    lnrpc.IRestoreChanBackupRequest,
+    lnrpc.RestoreChanBackupRequest,
+    lnrpc.RestoreBackupResponse
+  >({
+    request: lnrpc.RestoreChanBackupRequest,
+    response: lnrpc.RestoreBackupResponse,
+    method: "RestoreChannelBackups",
+    options: {
+      multiChanBackup: base64.toByteArray(channelsBackupBase64),
+    },
+  });
+  return response;
+};
+
 // TODO exception?
 // TODO move to a more appropriate file?
 export const subscribeInvoices = async (): Promise<string> => {
   try {
-    const response = await sendStreamCommand<lnrpc.IInvoiceSubscription, lnrpc.InvoiceSubscription>({
-      request: lnrpc.InvoiceSubscription,
-      method: "SubscribeInvoices",
-      options: {},
-    }, false);
+    const response = await sendStreamCommand<lnrpc.IInvoiceSubscription, lnrpc.InvoiceSubscription>(
+      {
+        request: lnrpc.InvoiceSubscription,
+        method: "SubscribeInvoices",
+        options: {},
+      },
+      false,
+    );
     return response;
-  } catch (e) { throw e.message; }
+  } catch (e) {
+    throw e.message;
+  }
 };
 
 // TODO error handling
diff --git a/src/state/index.ts b/src/state/index.ts
index 3fbab3623..05de14f1d 100644
--- a/src/state/index.ts
+++ b/src/state/index.ts
@@ -38,10 +38,14 @@ import { ISettingsModel, settings } from "./Settings";
 import { ITransactionModel, transaction } from "./Transaction";
 import { IWebLNModel, webln } from "./WebLN";
 import {
+  IImportChannelDbOnStartup,
   StorageItem,
+  brickInstance,
   clearApp,
   getAppBuild,
   getAppVersion,
+  getBrickDeviceAndExportChannelDb,
+  getImportChannelDbOnStartup,
   getItem as getItemAsyncStorage,
   getItemObject as getItemObjectAsyncStorage,
   getLndCompactDb,
@@ -49,6 +53,8 @@ import {
   getWalletCreated,
   setAppBuild,
   setAppVersion,
+  setBrickDeviceAndExportChannelDb,
+  setImportChannelDbOnStartup,
   setItem,
   setItemObject,
   setLndCompactDb,
@@ -110,6 +116,7 @@ export interface IStoreModel {
   setTorEnabled: Action<IStoreModel, boolean>;
   setTorLoading: Action<IStoreModel, boolean>;
   setSpeedloaderLoading: Action<IStoreModel, boolean>;
+  setImportChannelDbOnStartup: Action<IStoreModel, IImportChannelDbOnStartup>;
 
   generateSeed: Thunk<IStoreModel, string | undefined, IStoreInjections>;
   writeConfig: Thunk<IStoreModel, void, IStoreInjections, IStoreModel>;
@@ -147,12 +154,13 @@ export interface IStoreModel {
   blixtLsp: IBlixtLsp;
   contacts: IContactsModel;
   lightningBox: ILightningBoxModel;
+  channelAcceptanceManager: IChannelAcceptanceManagerModel;
 
   walletSeed?: string[];
   appVersion: number;
   appBuild: number;
   onboardingState: OnboardingState;
-  channelAcceptanceManager: IChannelAcceptanceManagerModel;
+  importChannelDbOnStartup: IImportChannelDbOnStartup | null;
 }
 
 export const model: IStoreModel = {
@@ -175,6 +183,38 @@ export const model: IStoreModel = {
     }
     log.v("initializeApp()");
 
+    const brickDeviceAndExportChannelDb = await getBrickDeviceAndExportChannelDb();
+    if (brickDeviceAndExportChannelDb) {
+      await NativeModules.LndMobileTools.saveChannelDbFile();
+      await brickInstance();
+      await setBrickDeviceAndExportChannelDb(false);
+      Alert.alert(
+        "",
+        "This Blixt wallet instance is now stopped and disabled.\nUse your channel.db file to restore on another device.\nTake extreme caution and do not restore on more than one device.",
+        [
+          {
+            text: "OK",
+            onPress() {
+              if (PLATFORM === "android") {
+                NativeModules.LndMobileTools.restartApp();
+              }
+            },
+          },
+        ],
+      );
+      return;
+    }
+
+    const importChannelDbOnStartup = await getImportChannelDbOnStartup();
+    if (importChannelDbOnStartup) {
+      actions.setImportChannelDbOnStartup(importChannelDbOnStartup);
+      const path = importChannelDbOnStartup.channelDbPath.replace(/^file:\/\//, "");
+      toast("Beginning channel db import procedure", undefined, "warning");
+      log.i("Beginning channel db import procedure", [path]);
+      await NativeModules.LndMobileTools.importChannelDbFile(path);
+      toast("Successfully imported channel.db");
+    }
+
     const { initialize, checkStatus, startLnd, gossipSync } = injections.lndMobile.index;
     const db = await actions.openDb();
     const firstStartup = !(await getItemObjectAsyncStorage(StorageItem.app));
@@ -412,6 +452,27 @@ export const model: IStoreModel = {
         log.i("Current lnd state", [state]);
         if (state.state === lnrpc.WalletState.NON_EXISTING) {
           log.d("Got lnrpc.WalletState.NON_EXISTING");
+
+          // Continue channel db import restore
+          if (importChannelDbOnStartup) {
+            log.i("Continuing restoration with channel import");
+            actions.setWalletSeed(importChannelDbOnStartup.seed);
+            await actions.createWallet({
+              restore: {
+                restoreWallet: true,
+                aezeedPassphrase: importChannelDbOnStartup.passphrase,
+              },
+            });
+
+            await Promise.all([
+              actions.settings.changeAutopilotEnabled(false),
+              actions.scheduledSync.setSyncEnabled(true), // TODO test
+              actions.settings.changeScheduledSyncEnabled(true),
+              actions.changeOnboardingState("DONE"),
+            ]);
+
+            setImportChannelDbOnStartup(null);
+          }
         } else if (state.state === lnrpc.WalletState.LOCKED) {
           log.d("Got lnrpc.WalletState.LOCKED");
           log.d("Wallet locked, unlocking wallet");
@@ -702,6 +763,9 @@ routerrpc.estimator=${lndPathfindingAlgorithm}
   setSpeedloaderLoading: action((state, value) => {
     state.speedloaderLoading = value;
   }),
+  setImportChannelDbOnStartup: action((state, value) => {
+    state.importChannelDbOnStartup = value;
+  }),
 
   appReady: false,
   walletCreated: false,
@@ -709,6 +773,7 @@ routerrpc.estimator=${lndPathfindingAlgorithm}
   appVersion: 0,
   appBuild: 0,
   onboardingState: "SEND_ONCHAIN",
+  importChannelDbOnStartup: null,
   torEnabled: false,
   torLoading: false,
 
diff --git a/src/storage/app.ts b/src/storage/app.ts
index 3c37d2daf..a0812e0aa 100644
--- a/src/storage/app.ts
+++ b/src/storage/app.ts
@@ -26,6 +26,9 @@ const APP_VERSION = appMigration.length - 1;
 
 export enum StorageItem { // const enums not supported in Babel 7...
   app = "app",
+  brickDeviceAndExportChannelDb = "brickDeviceAndExportChannelDb", // This is used to copy the channel.db file when lnd is down
+  bricked = "bricked", // This is used when channel.db migration is commenced
+  importChannelDbOnStartup = "importChannelDbOnStartup",
   appVersion = "appVersion",
   appBuild = "appBuild",
   databaseCreated = "databaseCreated",
@@ -93,6 +96,12 @@ export enum StorageItem { // const enums not supported in Babel 7...
   randomizeSettingsOnStartup = "randomizeSettingsOnStartup",
 }
 
+export interface IImportChannelDbOnStartup {
+  channelDbPath: string;
+  seed: string[];
+  passphrase: string;
+}
+
 export const setItem = async (key: StorageItem, value: string) =>
   await AsyncStorage.setItem(key, value);
 export const setItemObject = async <T>(key: StorageItem, value: T) =>
@@ -128,11 +137,40 @@ export const setRescanWallet = async (rescan: boolean): Promise<void> => {
 export const setLndCompactDb = async (rescan: boolean): Promise<void> => {
   return await setItemObject<boolean>(StorageItem.lndCompactDb, rescan);
 };
+export const setBrickDeviceAndExportChannelDb = async (brick: boolean): Promise<void> => {
+  return await setItemObject<boolean>(StorageItem.brickDeviceAndExportChannelDb, brick);
+};
+export const getBrickDeviceAndExportChannelDb = async (): Promise<boolean> => {
+  return await getItemObject<boolean>(StorageItem.brickDeviceAndExportChannelDb);
+};
+export const brickInstance = async (): Promise<void> => {
+  return await setItemObject<boolean>(StorageItem.bricked, true);
+};
+export const isInstanceBricked = async (): Promise<boolean> => {
+  return await getItemObject<boolean>(StorageItem.bricked);
+};
+export const setImportChannelDbOnStartup = async (
+  value: IImportChannelDbOnStartup | null,
+): Promise<void> => {
+  return await setItemObject<IImportChannelDbOnStartup>(
+    StorageItem.importChannelDbOnStartup,
+    value,
+  );
+};
+export const getImportChannelDbOnStartup = async (): Promise<IImportChannelDbOnStartup> => {
+  return await getItemObject<IImportChannelDbOnStartup>(StorageItem.importChannelDbOnStartup);
+};
+export const removeImportChannelDbOnStartupKvItem = async (): Promise<void> => {
+  return removeItem(StorageItem.importChannelDbOnStartup);
+};
 
 export const clearApp = async () => {
   // TODO use AsyncStorage.clear?
   await Promise.all([
     removeItem(StorageItem.app),
+    removeItem(StorageItem.brickDeviceAndExportChannelDb),
+    removeItem(StorageItem.bricked),
+    removeItem(StorageItem.importChannelDbOnStartup),
     removeItem(StorageItem.appVersion),
     removeItem(StorageItem.appBuild),
     removeItem(StorageItem.walletCreated),
@@ -226,6 +264,9 @@ export const setupApp = async () => {
 
   await Promise.all([
     setItemObject<boolean>(StorageItem.app, true),
+    setItemObject<boolean>(StorageItem.brickDeviceAndExportChannelDb, false),
+    setItemObject<boolean>(StorageItem.bricked, false),
+    setItemObject<IImportChannelDbOnStartup>(StorageItem.bricked, null),
     setItemObject<number>(StorageItem.appVersion, APP_VERSION),
     setItemObject<number>(StorageItem.appBuild, VersionCode),
     setItemObject<boolean>(StorageItem.walletCreated, false),
diff --git a/src/windows/InitProcess/DEV_Commands.tsx b/src/windows/InitProcess/DEV_Commands.tsx
index 3ed63670f..77c71956d 100644
--- a/src/windows/InitProcess/DEV_Commands.tsx
+++ b/src/windows/InitProcess/DEV_Commands.tsx
@@ -145,6 +145,22 @@ export default function DEV_Commands({ navigation, continueCallback }: IProps) {
             </>
           )}
           <Text style={{ width: "100%" }}>Random:</Text>
+          <Button
+            small
+            onPress={async () => {
+              setItemObject<boolean>(StorageItem.bricked, false);
+            }}
+          >
+            <Text style={styles.buttonText}>set bricked false</Text>
+          </Button>
+          <Button
+            small
+            onPress={async () => {
+              setItemObject<boolean>(StorageItem.bricked, true);
+            }}
+          >
+            <Text style={styles.buttonText}>set bricked true</Text>
+          </Button>
           <Button
             small
             onPress={async () => {
diff --git a/src/windows/Settings/Settings.tsx b/src/windows/Settings/Settings.tsx
index 782b5bd19..d8bbee268 100644
--- a/src/windows/Settings/Settings.tsx
+++ b/src/windows/Settings/Settings.tsx
@@ -42,6 +42,9 @@ import { fromUnixTime } from "date-fns";
 import { readFile } from "react-native-fs";
 import { useTranslation } from "react-i18next";
 import { routerrpc } from "../../../proto/lightning";
+import { blixtTheme } from "../../native-base-theme/variables/commonColor";
+import { brickInstance, setBrickDeviceAndExportChannelDb } from "../../storage/app";
+import { restoreChannelBackups } from "../../lndmobile/wallet";
 
 let ReactNativePermissions: any;
 if (PLATFORM !== "macos") {
@@ -1575,6 +1578,55 @@ ${t("experimental.tor.disabled.msg2")}`;
     await changeRandomizeSettingsOnStartup(!randomizeSettingsOnStartup);
   };
 
+  // Export channel db and brick
+  const onPressExportChannelDbAndBrickInstance = async () => {
+    try {
+      if (PLATFORM === "android") {
+        await setSyncEnabled(false);
+        await changeScheduledSyncEnabled(false);
+      }
+
+      await setBrickDeviceAndExportChannelDb(true);
+      await NativeModules.LndMobile.stopLnd();
+
+      Alert.alert("Restart the app to continue the procedure.", "", [
+        {
+          text: "OK",
+          onPress() {
+            if (PLATFORM === "android") {
+              NativeModules.LndMobileTools.restartApp();
+            }
+          },
+        },
+      ]);
+    } catch (e: any) {
+      toast("Error: " + e.message, 10000, "danger");
+      return;
+    }
+  };
+
+  // Restore SCB file
+  const onPressRestoreChannelBackup = async () => {
+    try {
+      const res = await DocumentPicker.pickSingle({
+        type: [DocumentPicker.types.allFiles],
+      });
+      console.log(res);
+
+      let backupBase64: string;
+      const backupFileUri = PLATFORM === "ios" ? res.uri.replace(/%20/g, " ") : res.uri;
+      try {
+        backupBase64 = await readFile(backupFileUri, PLATFORM === "android" ? "base64" : undefined);
+      } catch (e) {
+        backupBase64 = await readFile(backupFileUri, PLATFORM === "android" ? undefined : "base64");
+      }
+
+      await restoreChannelBackups(backupBase64);
+    } catch (error) {
+      toast("Error: " + error.message, 10000, "danger");
+    }
+  };
+
   return (
     <Container>
       <Content style={{ padding: 10 }}>
@@ -2874,6 +2926,36 @@ ${t("experimental.tor.disabled.msg2")}`;
               <Text>Stop lnd</Text>
             </Body>
           </ListItem>
+          {PLATFORM === "android" && name === "Hampus" && (
+            <ListItem
+              style={style.listItem}
+              icon={true}
+              onPress={onPressExportChannelDbAndBrickInstance}
+            >
+              <Left>
+                <Icon style={style.icon} type="MaterialCommunityIcons" name="file-export" />
+              </Left>
+              <Body>
+                <Text>
+                  Export channel.db file and permanently disable this instance of Blixt Wallet
+                </Text>
+                <Text note={true}>
+                  Use this feature to migrate this wallet to another device or to lnd.
+                </Text>
+                <Text note={true} style={{ color: blixtTheme.red }}>
+                  Only do this if you're know what you're doing
+                </Text>
+              </Body>
+            </ListItem>
+          )}
+          <ListItem style={style.listItem} icon={true} onPress={onPressRestoreChannelBackup}>
+            <Left>
+              <Icon style={style.icon} type="MaterialCommunityIcons" name="file-export" />
+            </Left>
+            <Body>
+              <Text>Restore SCB channel backup file</Text>
+            </Body>
+          </ListItem>
         </List>
       </Content>
     </Container>
diff --git a/src/windows/Welcome/Restore.tsx b/src/windows/Welcome/Restore.tsx
index e647c8a15..1c3aaffcb 100644
--- a/src/windows/Welcome/Restore.tsx
+++ b/src/windows/Welcome/Restore.tsx
@@ -19,6 +19,7 @@ import { toast } from "../../utils";
 
 import { useTranslation } from "react-i18next";
 import { namespaces } from "../../i18n/i18n.constants";
+import { setImportChannelDbOnStartup } from "../../storage/app";
 
 const iconTopPadding = (StatusBar.currentHeight ?? 0) + getStatusBarHeight(true);
 
@@ -30,27 +31,37 @@ export default function Restore({ navigation }: IProps) {
   const [loading, setLoading] = useState(false);
   const [seedText, setSeedText] = useState("");
   const [passphraseText, setPassphraseText] = useState("");
-  const [backupType, setBackupType] = useState<"file" | "google_drive" | "icloud" | "macos" | "none">("none");
+  const [backupType, setBackupType] = useState<
+    "file" | "google_drive" | "icloud" | "macos" | "channeldb" | "none"
+  >("none");
   const [backupFile, setBackupFile] = useState<DocumentPickerResponse | null>(null);
+  const [channelDbFile, setChannelDbFile] = useState<DocumentPickerResponse | null>(null);
   const [macosBakBase64, setMacosBakBase64] = useState<string | undefined>();
   const [b64Backup, setB64Backup] = useState<string | null>(null);
   const setWalletSeed = useStoreActions((store) => store.setWalletSeed);
   const createWallet = useStoreActions((store) => store.createWallet);
   const isSignedInGoogle = useStoreState((store) => store.google.isSignedIn);
   const signInGoogle = useStoreActions((store) => store.google.signIn);
-  const googleDriveGetBackupFile = useStoreActions((store => store.googleDriveBackup.getBackupFile));
-  const iCloudGetBackup = useStoreActions((store => store.iCloudBackup.getBackup));
+  const googleDriveGetBackupFile = useStoreActions(
+    (store) => store.googleDriveBackup.getBackupFile,
+  );
+  const iCloudGetBackup = useStoreActions((store) => store.iCloudBackup.getBackup);
   const iCloudActive = useStoreState((store) => store.iCloudBackup.iCloudActive);
 
   const setSyncEnabled = useStoreActions((state) => state.scheduledSync.setSyncEnabled);
-  const changeScheduledSyncEnabled = useStoreActions((state) => state.settings.changeScheduledSyncEnabled);
+  const changeScheduledSyncEnabled = useStoreActions(
+    (state) => state.settings.changeScheduledSyncEnabled,
+  );
   const changeAutopilotEnabled = useStoreActions((store) => store.settings.changeAutopilotEnabled);
   const changeOnboardingState = useStoreActions((store) => store.changeOnboardingState);
 
   const onRestorePress = async () => {
     try {
       // Note: the first trim is not a mistake, it's to trim out "white-space words" that could exist after the split
-      const splittedSeed = seedText.trim().split(" ").map((word) => word.trim());
+      const splittedSeed = seedText
+        .trim()
+        .split(" ")
+        .map((word) => word.trim());
       if (splittedSeed.length !== 24) {
         Alert.alert(t("restore.seed"));
         return;
@@ -62,8 +73,8 @@ export default function Restore({ navigation }: IProps) {
         restore: {
           restoreWallet: true,
           aezeedPassphrase: passphraseText,
-        }
-      }
+        },
+      };
 
       if (backupType === "file") {
         if (backupFile) {
@@ -77,11 +88,18 @@ export default function Restore({ navigation }: IProps) {
           // For Android want `readFile` to convert the binary to base64.
           // For iOS we want `readFile` to just read the file as a string (it's already in base64).
           let backupBase64: string;
-          const backupFileUri = PLATFORM === "ios" ? backupFile.uri.replace(/%20/g, " ") : backupFile.uri;
+          const backupFileUri =
+            PLATFORM === "ios" ? backupFile.uri.replace(/%20/g, " ") : backupFile.uri;
           try {
-            backupBase64 = await readFile(backupFileUri, PLATFORM === "android" ? "base64" : undefined);
+            backupBase64 = await readFile(
+              backupFileUri,
+              PLATFORM === "android" ? "base64" : undefined,
+            );
           } catch (e) {
-            backupBase64 = await readFile(backupFileUri, PLATFORM === "android" ? undefined : "base64");
+            backupBase64 = await readFile(
+              backupFileUri,
+              PLATFORM === "android" ? undefined : "base64",
+            );
           }
           createWalletOpts.restore!.channelsBackup = backupBase64;
         }
@@ -89,6 +107,23 @@ export default function Restore({ navigation }: IProps) {
         createWalletOpts.restore!.channelsBackup = b64Backup!;
       } else if (backupType === "macos") {
         createWalletOpts.restore!.channelsBackup = macosBakBase64;
+      } else if (backupType === "channeldb") {
+        if (channelDbFile.copyError) {
+          throw new Error("channel.db file copying failed: " + channelDbFile.copyError);
+        }
+
+        // await NativeModules.LndMobile.stopLnd();
+        await setImportChannelDbOnStartup({
+          channelDbPath: channelDbFile.fileCopyUri.replace(/^file:\/\//, ""),
+          seed: splittedSeed,
+          passphrase: passphraseText,
+        });
+
+        Alert.alert(
+          "Success",
+          "Blixt Wallet needs to be restarted in order to continue with the restore procedure. Close Blixt Wallet now and start it up again.",
+        );
+        return;
       }
 
       await createWallet(createWalletOpts);
@@ -103,10 +138,8 @@ export default function Restore({ navigation }: IProps) {
       navigation.dispatch(
         CommonActions.reset({
           index: 0,
-          routes: [
-            { name: "Loading" },
-          ],
-        })
+          routes: [{ name: "Loading" }],
+        }),
       );
     } catch (e) {
       console.log(e);
@@ -134,7 +167,7 @@ export default function Restore({ navigation }: IProps) {
 
   const iCloudBackup = async () => {
     try {
-      const base64Backup = await iCloudGetBackup()
+      const base64Backup = await iCloudGetBackup();
       console.log(base64Backup);
       setB64Backup(base64Backup);
       setBackupType("icloud");
@@ -158,19 +191,39 @@ export default function Restore({ navigation }: IProps) {
         setMacosBakBase64(b);
         setBackupType("macos");
       }
+    } catch (e) {
+      console.log(e);
+      toast(e.message, undefined, "danger", "Okay");
+    }
+  };
 
+  const pickChannelDbFile = async () => {
+    try {
+      if (PLATFORM !== "android") {
+        toast("channel.db is not supported on this platform", undefined, "danger");
+        return;
+      }
+
+      setLoading(true);
+      const res = await DocumentPicker.pickSingle({
+        type: [DocumentPicker.types.allFiles],
+        copyTo: "documentDirectory",
+      });
+      setChannelDbFile(res);
+      setBackupType("channeldb");
+      setLoading(false);
     } catch (e) {
       console.log(e);
       toast(e.message, undefined, "danger", "Okay");
     }
-  }
+  };
 
   const undoBackupChoice = () => {
     setBackupFile(null);
     setB64Backup(null);
     setMacosBakBase64(null);
     setBackupType("none");
-  }
+  };
 
   return (
     <Container>
@@ -224,65 +277,75 @@ export default function Restore({ navigation }: IProps) {
             </View>
             <View style={{ marginTop: 14, width: "100%", display: "flex" }}>
               <H3>{t("restore.channel.title")}</H3>
-              {backupType === "none" &&
+              {backupType === "none" && (
                 <View style={{ display: "flex", flexDirection: "column" }}>
-                  <Button style={{ marginTop: 6, marginBottom: 10 }} small onPress={pickChannelsExportFile}>
-                    <Text>
-                      {backupFile === null && t("restore.channel.file")}
-                    </Text>
+                  <Button
+                    style={{ marginTop: 6, marginBottom: 10 }}
+                    small
+                    onPress={pickChannelsExportFile}
+                    onLongPress={pickChannelDbFile}
+                  >
+                    <Text>{backupFile === null && t("restore.channel.file")}</Text>
                   </Button>
-                  {PLATFORM === "android" &&
+                  {PLATFORM === "android" && (
                     <Button small onPress={googleDriveBackup}>
-                      <Text>
-                        {t("restore.channel.google.title")}
-                      </Text>
+                      <Text>{t("restore.channel.google.title")}</Text>
                     </Button>
-                  }
-                  {(PLATFORM === "ios" && iCloudActive) &&
+                  )}
+                  {PLATFORM === "ios" && iCloudActive && (
                     <Button small onPress={iCloudBackup}>
-                      <Text>
-                        {t("restore.channel.iCloud.title")}
-                      </Text>
+                      <Text>{t("restore.channel.iCloud.title")}</Text>
                     </Button>
-                  }
+                  )}
+                  {/* <Button
+                    small
+                    style={{ marginTop: 6, marginBottom: 10 }}
+                    onPress={pickChannelDbFile}
+                  >
+                    <Text>{t("restore.channel.importChannelDb.title")}</Text>
+                  </Button> */}
+                </View>
+              )}
+              {(backupType === "file" || backupType === "macos") && (
+                <View style={{ flexDirection: "row", justifyContent: "space-between" }}>
+                  <Text>{backupFile && backupFile.name}</Text>
+                  <Button small onPress={undoBackupChoice}>
+                    <Text>x</Text>
+                  </Button>
                 </View>
-              }
-              {(backupType === "file" || backupType === "macos") &&
-                <View style={{ flexDirection: "row", justifyContent: "space-between"}}>
-                  <Text>{backupFile &&  backupFile.name}</Text>
+              )}
+              {backupType === "channeldb" && (
+                <View style={{ flexDirection: "row", justifyContent: "space-between" }}>
+                  <Text>{channelDbFile && channelDbFile.name}</Text>
                   <Button small onPress={undoBackupChoice}>
-                    <Text>
-                      x
-                    </Text>
+                    <Text>x</Text>
                   </Button>
                 </View>
-              }
-              {backupType === "google_drive" &&
-                <View style={{ flexDirection: "row", justifyContent: "space-between"}}>
+              )}
+              {backupType === "google_drive" && (
+                <View style={{ flexDirection: "row", justifyContent: "space-between" }}>
                   <Text>{t("backup.google")}</Text>
                   <Button small onPress={undoBackupChoice}>
-                    <Text>
-                      x
-                    </Text>
+                    <Text>x</Text>
                   </Button>
                 </View>
-              }
-              {backupType === "icloud" &&
-                <View style={{ flexDirection: "row", justifyContent: "space-between"}}>
+              )}
+              {backupType === "icloud" && (
+                <View style={{ flexDirection: "row", justifyContent: "space-between" }}>
                   <Text>{t("backup.iCloud")}</Text>
                   <Button small onPress={undoBackupChoice}>
-                    <Text>
-                      x
-                    </Text>
+                    <Text>x</Text>
                   </Button>
                 </View>
-              }
+              )}
             </View>
           </View>
           <View style={style.text}>
             <H1 style={style.textHeader}>{t("restore.title")}</H1>
             <Text>
-              {t("restore.msg")}{"\n"}{"\n"}
+              {t("restore.msg")}
+              {"\n"}
+              {"\n"}
               {t("restore.msg1")}
             </Text>
           </View>
@@ -352,9 +415,7 @@ const style = StyleSheet.create({
   textHeader: {
     marginBottom: 3,
   },
-  card: {
-
-  },
+  card: {},
   cardItem: {
     width: "100%",
     flex: 1,