diff --git a/Cargo.lock b/Cargo.lock
index 4d6ab9b..2a26c42 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5175,7 +5175,8 @@ dependencies = [
 [[package]]
 name = "tauri-plugin-window"
 version = "2.0.0-alpha.1"
-source = "git+https://git.nextgraph.org/NextGraph/plugins-workspace.git?branch=window-alpha.1-nextgraph#0beae8162f66bcb8a1ec902738507f7ebe6b8a5e"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06f3c1d40ae1a1b2b837e7f9b8db80aa2ee8c4594f63d729d2abd69f0741225a"
 dependencies = [
  "serde",
  "tauri",
diff --git a/Cargo.toml b/Cargo.toml
index 7cc0513..775ff15 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -18,4 +18,8 @@ members = [
 
 [profile.release]
 lto = true
-opt-level = 's'
\ No newline at end of file
+opt-level = 's'
+
+[patch.crates-io]
+# tauri = { git = "https://github.com/simonhyll/tauri.git",  branch="fix/ipc-mixup"}
+tauri = { git = "https://git.nextgraph.org/NextGraph/tauri.git", branch="alpha.11-nextgraph", features = ["no-ipc-custom-protocol"] }
\ No newline at end of file
diff --git a/ng-app/src-tauri/Cargo.toml b/ng-app/src-tauri/Cargo.toml
index 18aeaed..039495e 100644
--- a/ng-app/src-tauri/Cargo.toml
+++ b/ng-app/src-tauri/Cargo.toml
@@ -21,13 +21,15 @@ tauri-build = { version = "2.0.0-alpha.6", features = [] }
 
 [dependencies]
 tauri = { git = "https://git.nextgraph.org/NextGraph/tauri.git", branch="alpha.11-nextgraph", features = ["no-ipc-custom-protocol"] }
+# tauri = { git = "https://github.com/simonhyll/tauri.git", branch="fix/ipc-mixup", features = [] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 p2p-repo = { path = "../../p2p-repo" }
 p2p-net = { path = "../../p2p-net" }
 ng-wallet = { path = "../../ng-wallet" }
 async-std = {  version = "1.12.0", features = ["attributes", "unstable"] }
-tauri-plugin-window = { git = "https://git.nextgraph.org/NextGraph/plugins-workspace.git", branch="window-alpha.1-nextgraph" }
+# tauri-plugin-window = { git = "https://git.nextgraph.org/NextGraph/plugins-workspace.git", branch="window-alpha.1-nextgraph" }
+tauri-plugin-window = "2.0.0-alpha.1"
 
 [features]
 # this feature is used for production builds or when `devPath` points to the filesystem
diff --git a/ng-app/src-tauri/src/lib.rs b/ng-app/src-tauri/src/lib.rs
index bb9b160..458acc8 100644
--- a/ng-app/src-tauri/src/lib.rs
+++ b/ng-app/src-tauri/src/lib.rs
@@ -12,6 +12,7 @@ use ng_wallet::*;
 use p2p_net::broker::*;
 use p2p_net::types::{CreateAccountBSP, Invitation};
 use p2p_net::utils::{decode_invitation_string, spawn_and_log_error, Receiver, ResultSend};
+use p2p_repo::errors::NgError;
 use p2p_repo::log::*;
 use p2p_repo::types::*;
 use std::collections::HashMap;
@@ -115,21 +116,92 @@ async fn save_wallet_locally(
         .path()
         .resolve("wallets", BaseDirectory::AppLocalData)
         .map_err(|_| ())?;
-    let sws = save_new_session(&res.wallet_name, res.wallet.id(), res.user, app.clone())?;
-    let mut wallets: HashMap<String, LocalWalletStorageV0> = get_wallets_from_localstorage(app)
-        .await
-        .unwrap_or(Some(HashMap::new()))
-        .unwrap_or(HashMap::new());
-    // TODO: check that the wallet is not already present in localStorage
-    let lws: LocalWalletStorageV0 = res.into();
-    wallets.insert(res.wallet_name.clone(), lws);
-    let lws_ser = LocalWalletStorage::v0_to_vec(wallets);
-    let r = write(path.clone(), &lws_ser);
-    if r.is_err() {
-        log_debug!("write {:?} {}", path, r.unwrap_err());
-        return Err(());
+    let mut wallets: HashMap<String, LocalWalletStorageV0> =
+        get_wallets_from_localstorage(app.clone())
+            .await
+            .unwrap_or(Some(HashMap::new()))
+            .unwrap_or(HashMap::new());
+    // check that the wallet is not already present in localStorage
+    if wallets.get(&res.wallet_name).is_none() {
+        let lws: LocalWalletStorageV0 = res.into();
+        wallets.insert(res.wallet_name.clone(), lws);
+        let lws_ser = LocalWalletStorage::v0_to_vec(wallets);
+        let r = write(path.clone(), &lws_ser);
+        if r.is_err() {
+            log_debug!("write {:?} {}", path, r.unwrap_err());
+            return Err(());
+        }
+        let sws = save_new_session(&res.wallet_name, res.wallet.id(), res.user, app)?;
+        Ok(sws)
+    } else {
+        Err(())
+    }
+}
+
+#[tauri::command(rename_all = "snake_case")]
+async fn wallet_open_file(file: Vec<u8>, app: tauri::AppHandle) -> Result<Wallet, String> {
+    let ngf: NgFile = file.try_into().map_err(|e: NgError| e.to_string())?;
+    if let NgFile::V0(NgFileV0::Wallet(wallet)) = ngf {
+        let mut wallets: HashMap<String, LocalWalletStorageV0> =
+            get_wallets_from_localstorage(app.clone())
+                .await
+                .unwrap_or(Some(HashMap::new()))
+                .unwrap_or(HashMap::new());
+        // check that the wallet is not already present in localStorage
+        let wallet_name = wallet.name();
+        if wallets.get(&wallet_name).is_none() {
+            Ok(wallet)
+        } else {
+            Err("Wallet already present on this device".to_string())
+        }
+    } else {
+        Err("File does not contain a wallet".to_string())
+    }
+}
+
+#[tauri::command(rename_all = "snake_case")]
+async fn wallet_import(
+    previous_wallet: Wallet,
+    opened_wallet: EncryptedWallet,
+    app: tauri::AppHandle,
+) -> Result<(), String> {
+    let path = app
+        .path()
+        .resolve("wallets", BaseDirectory::AppLocalData)
+        .map_err(|_| "wallet directory error".to_string())?;
+    let mut wallets: HashMap<String, LocalWalletStorageV0> =
+        get_wallets_from_localstorage(app.clone())
+            .await
+            .unwrap_or(Some(HashMap::new()))
+            .unwrap_or(HashMap::new());
+    // check that the wallet is not already present in localStorage
+    let EncryptedWallet::V0(mut opened_wallet_v0) = opened_wallet;
+    let wallet_name = opened_wallet_v0.wallet_id.clone();
+    if wallets.get(&wallet_name).is_none() {
+        let session = save_new_session(
+            &wallet_name,
+            opened_wallet_v0.wallet_privkey.to_pub(),
+            opened_wallet_v0.personal_site,
+            app,
+        )
+        .map_err(|_| "Cannot create new session".to_string())?;
+        let (wallet, client) = opened_wallet_v0
+            .import(previous_wallet, session)
+            .map_err(|e| e.to_string())?;
+        let lws = LocalWalletStorageV0::new(wallet, client);
+
+        wallets.insert(wallet_name, lws);
+        let lws_ser = LocalWalletStorage::v0_to_vec(wallets);
+        let r = write(path.clone(), &lws_ser);
+        if r.is_err() {
+            log_debug!("write {:?} {}", path, r.unwrap_err());
+            Err("Write error".to_string())
+        } else {
+            Ok(())
+        }
+    } else {
+        Err("Already present on this device".to_string())
     }
-    Ok(sws)
 }
 
 #[tauri::command(rename_all = "snake_case")]
@@ -161,7 +233,7 @@ fn save_new_session(
         .map_err(|_| ())?;
     let session_v0 = create_new_session(wallet_id, user);
     if session_v0.is_err() {
-        log_debug!("create_new_session {}", session_v0.unwrap_err());
+        log_debug!("create_new_session failed {}", session_v0.unwrap_err());
         return Err(());
     }
     let sws = session_v0.unwrap();
@@ -356,6 +428,8 @@ impl AppBuilder {
                 wallet_gen_shuffle_for_pin,
                 wallet_open_wallet_with_pazzle,
                 wallet_create_wallet,
+                wallet_open_file,
+                wallet_import,
                 encode_create_account,
                 get_local_session,
                 get_wallets_from_localstorage,
diff --git a/ng-app/src/api.ts b/ng-app/src/api.ts
index d171b4f..365ada3 100644
--- a/ng-app/src/api.ts
+++ b/ng-app/src/api.ts
@@ -18,6 +18,8 @@ const mapping = {
     "wallet_gen_shuffle_for_pin": [],
     "wallet_open_wallet_with_pazzle": ["wallet","pazzle","pin"],
     "wallet_create_wallet": ["params"],
+    "wallet_open_file": ["file"],
+    "wallet_import": ["previous_wallet","opened_wallet"],
     "encode_create_account": ["payload"],
     "get_local_session": ["id","key","user"],
     "get_wallets_from_localstorage": [],
@@ -122,6 +124,14 @@ const handler = {
                 params.result_with_wallet_file = false;
                 params.security_img = Array.from(new Uint8Array(params.security_img));
                 return await tauri.invoke(path[0],{params})
+            } else if (path[0] === "wallet_open_file") {
+                let file = args[0];
+                file = Array.from(new Uint8Array(file));
+                return await tauri.invoke(path[0],{file})
+            } else if (path[0] === "wallet_import") {
+                let previous_wallet = args[0];
+                previous_wallet.V0.content.security_img = Array.from(new Uint8Array(previous_wallet.V0.content.security_img));
+                return await tauri.invoke(path[0],{previous_wallet, opened_wallet:args[1]})
             } else if (path[0] && path[0].startsWith("get_local_bootstrap")) {
                 return false;
             } else if (path[0] === "get_local_url") {
diff --git a/ng-app/src/lib/Login.svelte b/ng-app/src/lib/Login.svelte
index b0d320a..1d2296c 100644
--- a/ng-app/src/lib/Login.svelte
+++ b/ng-app/src/lib/Login.svelte
@@ -23,7 +23,7 @@
 
   onMount(async () => {
     await load_svg();
-    console.log(wallet);
+    //console.log(wallet);
     await init();
   });
 
@@ -81,10 +81,10 @@
 
   async function start_pin() {
     pin_code = [];
-    console.log(ordered);
+    //console.log(ordered);
     shuffle_pin = await ng.wallet_gen_shuffle_for_pin();
     step = "pin";
-    console.log(shuffle_pin);
+    //console.log(shuffle_pin);
   }
 
   function select(val) {
@@ -92,10 +92,10 @@
     let cat_idx = shuffle.category_indices[display];
     let cat = emojis[emoji_cat[cat_idx]];
     let idx = shuffle.emoji_indices[display][val];
-    console.log(cat_idx, emoji_cat[cat_idx], idx, cat[idx].code);
+    //console.log(cat_idx, emoji_cat[cat_idx], idx, cat[idx].code);
 
     selection.push({ cat: cat_idx, index: idx });
-    console.log(selection);
+    //console.log(selection);
 
     if (display == pazzle_length - 1) {
       order();
@@ -113,8 +113,8 @@
       pazzle.push((emoji.cat << 4) + emoji.index);
     }
 
-    console.log(pazzle);
-    console.log(wallet);
+    //console.log(pazzle);
+    //console.log(wallet);
 
     // open the wallet
     try {
@@ -143,7 +143,7 @@
   }
 
   async function pin(val) {
-    console.log(val);
+    //console.log(val);
     pin_code.push(val);
     if (pin_code.length == 4) {
       await finish();
@@ -152,8 +152,8 @@
 
   async function select_order(val, pos) {
     delete last_one[pos];
-    console.log(last_one);
-    console.log(val);
+    //console.log(last_one);
+    //console.log(val);
     ordered.push(val);
     val.sel = ordered.length;
     selection = selection;
@@ -162,7 +162,7 @@
       ordered.push(last);
       last.sel = ordered.length;
       selection = selection;
-      console.log(last);
+      //console.log(last);
       await start_pin();
     }
   }
@@ -195,7 +195,9 @@
   </div>
 {:else if step == "pazzle"}
   <div
-    class="h-screen aspect-[3/5] pazzleline min-w-[350px]"
+    class="h-screen aspect-[3/5] pazzleline"
+    class:min-w-[350px]={mobile}
+    class:min-w-[500px]={!mobile}
     class:max-w-[360px]={mobile}
     class:max-w-[600px]={!mobile}
   >
@@ -218,7 +220,9 @@
 {:else if step == "order"}
   <!-- console.log(cat_idx, emoji_cat[cat_idx], idx, cat[idx].code); -->
   <div
-    class="h-screen aspect-[3/3] pazzleline min-w-[350px]"
+    class="h-screen aspect-[3/3] pazzleline"
+    class:min-w-[350px]={mobile}
+    class:min-w-[500px]={!mobile}
     class:max-w-[360px]={mobile}
     class:max-w-[600px]={!mobile}
   >
diff --git a/ng-app/src/routes/WalletLogin.svelte b/ng-app/src/routes/WalletLogin.svelte
index 81f58e5..5f07b7d 100644
--- a/ng-app/src/routes/WalletLogin.svelte
+++ b/ng-app/src/routes/WalletLogin.svelte
@@ -14,6 +14,7 @@
   import { link, push } from "svelte-spa-router";
   import Login from "../lib/Login.svelte";
   import ng from "../api";
+  import { Fileupload } from "flowbite-svelte";
   // @ts-ignore
   import Logo from "../assets/nextgraph.svg?component";
   import {
@@ -27,6 +28,8 @@
   let wallet;
   let selected;
   let step;
+  let error;
+  let importing = false;
 
   let wallets_unsub;
   let opened_wallets_unsub;
@@ -59,7 +62,7 @@
             value.wallet.V0.wallet_privkey,
             value.wallet.V0.personal_site
           );
-          console.log(session);
+          //console.log(session);
           if (session) {
             set_active_session(session);
             loggedin();
@@ -80,15 +83,29 @@
     if (active_wallet_unsub) active_wallet_unsub();
   });
   async function gotError(event) {
+    importing = false;
     console.error(event.detail);
   }
   async function gotWallet(event) {
-    console.log(event.detail);
+    //console.log(event.detail);
+    if (importing) {
+      try {
+        await ng.wallet_import(wallet, event.detail.wallet);
+        let walls = await ng.get_wallets_from_localstorage();
+        wallets.set(walls);
+      } catch (e) {
+        importing = false;
+        wallet = undefined;
+        error = e;
+        return;
+      }
+    }
     active_wallet.set(event.detail);
     // wallet
     // id
   }
   function cancelLogin(event) {
+    importing = false;
     selected = undefined;
     wallet = undefined;
   }
@@ -100,9 +117,57 @@
       wallet = $wallets[selected]?.wallet;
     }
   }
+  function handleWalletUpload(event) {
+    const files = event.target.files;
+    if (files.length > 0) {
+      let reader = new FileReader();
+      reader.readAsArrayBuffer(files[0]);
+      reader.onload = async (e) => {
+        try {
+          //console.log(e.target.result);
+          wallet = await ng.wallet_open_file(e.target.result);
+          importing = true;
+        } catch (e) {
+          error = e;
+        }
+      };
+    }
+  }
 </script>
 
-{#if wallet}
+{#if error}
+  <div class=" max-w-6xl lg:px-8 mx-auto px-4 text-red-800">
+    <svg
+      class="animate-bounce mt-10 h-16 w-16 mx-auto"
+      fill="none"
+      stroke="currentColor"
+      stroke-width="1.5"
+      viewBox="0 0 24 24"
+      xmlns="http://www.w3.org/2000/svg"
+      aria-hidden="true"
+    >
+      <path
+        stroke-linecap="round"
+        stroke-linejoin="round"
+        d="M12 9v3.75m-9.303 3.376c-.866 1.5.217 3.374 1.948 3.374h14.71c1.73 0 2.813-1.874 1.948-3.374L13.949 3.378c-.866-1.5-3.032-1.5-3.898 0L2.697 16.126zM12 15.75h.007v.008H12v-.008z"
+      />
+    </svg>
+
+    <p class="max-w-xl md:mx-auto lg:max-w-2xl mb-5">
+      An error occurred:<br />{error}
+    </p>
+    <button
+      on:click={() => {
+        importing = false;
+        error = undefined;
+        wallet = undefined;
+      }}
+      class="text-white bg-primary-700 hover:bg-primary-700/90 focus:ring-4 focus:outline-none focus:ring-primary-700/50 font-medium rounded-lg text-lg px-5 py-2.5 text-center inline-flex items-center dark:focus:ring-primary-700/55 mb-2"
+    >
+      Start over
+    </button>
+  </div>
+{:else if wallet}
   <Login
     {wallet}
     on:error={gotError}
@@ -146,8 +211,17 @@
         {#if $has_wallets}<p class="mt-1">Log in with another wallet</p>
         {:else}<p class="mt-1">Import your wallet</p>
         {/if}
+        <Fileupload
+          style="display:none;"
+          id="import_wallet_file"
+          accept=".ngw, .txt"
+          on:change={handleWalletUpload}
+        />
         <button
           class=" mt-1 text-primary-700 bg-primary-100 hover:bg-primary-100/90 focus:ring-4 focus:outline-none focus:ring-primary-700/50 font-medium rounded-lg text-lg px-5 py-2.5 text-center inline-flex items-center dark:focus:ring-primary-100/55 mb-2"
+          on:click={() => {
+            document.getElementById("import_wallet_file").click();
+          }}
         >
           <svg
             class="w-8 h-8 mr-2 -ml-1"
@@ -238,7 +312,7 @@
       </div>
     </div>
   </main>
-{:else if step == "security"}{:else if step == "qrcode"}{:else if step == "drop"}{:else if step == "cloud"}{:else if step == "loggedin"}you
+{:else if step == "security"}{:else if step == "qrcode"}{:else if step == "cloud"}{:else if step == "loggedin"}you
   are logged in{/if}
 
 <style>
@@ -249,7 +323,7 @@
     position: relative;
     cursor: pointer;
   }
-  button {
+  .wallet-box button {
     min-width: 250px;
   }
   .securitytxt {
diff --git a/ng-sdk-js/src/lib.rs b/ng-sdk-js/src/lib.rs
index d511bd4..1b482f5 100644
--- a/ng-sdk-js/src/lib.rs
+++ b/ng-sdk-js/src/lib.rs
@@ -30,6 +30,7 @@ use p2p_net::utils::{decode_invitation_string, spawn_and_log_error, Receiver, Re
 use p2p_net::utils::{retrieve_local_bootstrap, retrieve_local_url};
 
 use p2p_net::WS_PORT;
+use p2p_repo::errors::NgError;
 use p2p_repo::log::*;
 use p2p_repo::types::*;
 use p2p_repo::utils::generate_keypair;
@@ -263,6 +264,73 @@ pub async fn wallet_create_wallet(js_params: JsValue) -> Result<JsValue, JsValue
     }
 }
 
+#[cfg(target_arch = "wasm32")]
+#[wasm_bindgen]
+pub async fn wallet_open_file(js_file: JsValue) -> Result<JsValue, String> {
+    let mut file = serde_wasm_bindgen::from_value::<serde_bytes::ByteBuf>(js_file)
+        .map_err(|_| "Deserialization error of file".to_string())?;
+
+    let ngf: NgFile = file
+        .into_vec()
+        .try_into()
+        .map_err(|e: NgError| e.to_string())?;
+    if let NgFile::V0(NgFileV0::Wallet(wallet)) = ngf {
+        let wallets: HashMap<String, LocalWalletStorageV0> =
+            get_local_wallets_v0().unwrap_or(HashMap::new());
+        // check that the wallet is not already present in localStorage
+        let wallet_name = wallet.name();
+        if wallets.get(&wallet_name).is_none() {
+            Ok(serde_wasm_bindgen::to_value(&wallet).unwrap())
+        } else {
+            Err("Wallet already present on this device".to_string())
+        }
+    } else {
+        Err("File does not contain a wallet".to_string())
+    }
+}
+
+#[cfg(target_arch = "wasm32")]
+#[wasm_bindgen]
+pub async fn wallet_import(
+    js_previous_wallet: JsValue, //Wallet,
+    js_opened_wallet: JsValue,   //EncryptedWallet
+) -> Result<(), String> {
+    let previous_wallet = serde_wasm_bindgen::from_value::<Wallet>(js_previous_wallet)
+        .map_err(|_| "Deserialization error of Wallet".to_string())?;
+    let mut opened_wallet = serde_wasm_bindgen::from_value::<EncryptedWallet>(js_opened_wallet)
+        .map_err(|_| "Deserialization error of EncryptedWalletV0".to_string())?;
+
+    let EncryptedWallet::V0(mut opened_wallet_v0) = opened_wallet;
+    let mut wallets: HashMap<String, LocalWalletStorageV0> =
+        get_local_wallets_v0().unwrap_or(HashMap::new());
+    // check that the wallet is not already present in localStorage
+    let wallet_name = opened_wallet_v0.wallet_id.clone();
+    if wallets.get(&wallet_name).is_none() {
+        let session = save_new_session(
+            &wallet_name,
+            opened_wallet_v0.wallet_privkey.to_pub(),
+            opened_wallet_v0.personal_site,
+        )
+        .map_err(|e| format!("Cannot create new session: {e}"))?;
+        let (wallet, client) = opened_wallet_v0
+            .import(previous_wallet, session)
+            .map_err(|e| e.to_string())?;
+        let lws = LocalWalletStorageV0::new(wallet, client);
+
+        wallets.insert(wallet_name, lws);
+
+        let lws_ser = serde_bare::to_vec(&LocalWalletStorage::V0(wallets)).unwrap();
+        let encoded = base64_url::encode(&lws_ser);
+        let r = local_save("ng_wallets".to_string(), encoded);
+        if r.is_some() {
+            return Err(r.unwrap());
+        }
+        Ok(())
+    } else {
+        Err("Wallet already present on this device".to_string())
+    }
+}
+
 #[cfg(target_arch = "wasm32")]
 #[wasm_bindgen]
 pub fn test_create_wallet() -> JsValue {
diff --git a/ng-wallet/src/lib.rs b/ng-wallet/src/lib.rs
index ffe7190..d55aaa9 100644
--- a/ng-wallet/src/lib.rs
+++ b/ng-wallet/src/lib.rs
@@ -35,13 +35,89 @@ use image::{imageops::FilterType, io::Reader as ImageReader, ImageOutputFormat};
 use safe_transmute::transmute_to_bytes;
 
 use p2p_net::types::{SiteType, SiteV0};
-use p2p_repo::types::{PubKey, Timestamp};
+use p2p_repo::types::{PubKey, Sig, Timestamp};
 use p2p_repo::utils::{generate_keypair, now_timestamp, sign, verify};
 use p2p_repo::{log::*, types::PrivKey};
 use rand::prelude::*;
 use serde_bare::{from_slice, to_vec};
 use web_time::Instant;
 
+impl Wallet {
+    pub fn id(&self) -> WalletId {
+        match self {
+            Wallet::V0(v0) => v0.id,
+        }
+    }
+    pub fn content_as_bytes(&self) -> Vec<u8> {
+        match self {
+            Wallet::V0(v0) => serde_bare::to_vec(&v0.content).unwrap(),
+        }
+    }
+    pub fn sig(&self) -> Sig {
+        match self {
+            Wallet::V0(v0) => v0.sig,
+        }
+    }
+    pub fn pazzle_length(&self) -> u8 {
+        match self {
+            Wallet::V0(v0) => v0.content.pazzle_length,
+        }
+    }
+    pub fn name(&self) -> String {
+        match self {
+            Wallet::V0(v0) => base64_url::encode(&v0.id.slice()),
+        }
+    }
+
+    pub fn encrypt(
+        &self,
+        wallet_log: &WalletLog,
+        master_key: &[u8; 32],
+        peer_id: PubKey,
+        nonce: u64,
+        wallet_privkey: PrivKey,
+    ) -> Result<Self, NgWalletError> {
+        let timestamp = now_timestamp();
+        let wallet_id = self.id();
+        let encrypted =
+            enc_wallet_log(wallet_log, master_key, peer_id, nonce, timestamp, wallet_id)?;
+
+        let mut wallet_content = match self {
+            Wallet::V0(v0) => v0.content.clone(),
+        };
+
+        wallet_content.timestamp = timestamp;
+        wallet_content.peer_id = peer_id;
+        wallet_content.nonce = nonce;
+        wallet_content.encrypted = encrypted;
+
+        let ser_wallet = serde_bare::to_vec(&wallet_content).unwrap();
+
+        let sig = sign(&wallet_privkey, &wallet_id, &ser_wallet).unwrap();
+
+        let wallet_v0 = WalletV0 {
+            /// ID
+            id: wallet_id,
+            /// Content
+            content: wallet_content,
+            /// Signature over content by wallet's private key
+            sig,
+        };
+
+        // let content = BootstrapContentV0 { servers: vec![] };
+        // let ser = serde_bare::to_vec(&content).unwrap();
+        // let sig = sign(wallet_key, wallet_id, &ser).unwrap();
+
+        // let bootstrap = Bootstrap::V0(BootstrapV0 {
+        //     id: wallet_id,
+        //     content,
+        //     sig,
+        // });
+
+        Ok(Wallet::V0(wallet_v0))
+    }
+}
+
 pub fn enc_master_key(
     master_key: &[u8; 32],
     key: &[u8; 32],
@@ -161,7 +237,7 @@ pub fn create_new_session(
 
 pub fn dec_encrypted_block(
     mut ciphertext: Vec<u8>,
-    master_key: &mut [u8; 32],
+    master_key: [u8; 32],
     peer_id: PubKey,
     nonce: u64,
     timestamp: Timestamp,
@@ -183,13 +259,13 @@ pub fn dec_encrypted_block(
     let decrypted_log =
         from_slice::<WalletLog>(&ciphertext).map_err(|e| NgWalletError::DecryptionError)?;
 
-    master_key.zeroize();
+    //master_key.zeroize(); // this is now donw in the EncryptedWalletV0
 
     // `ciphertext` now contains the decrypted block
     //log_debug!("decrypted_block {:?}", ciphertext);
 
     match decrypted_log {
-        WalletLog::V0(v0) => v0.reduce(),
+        WalletLog::V0(v0) => v0.reduce(master_key),
     }
 }
 
@@ -244,7 +320,7 @@ pub fn open_wallet_with_pazzle(
             //pazzle.zeroize();
             pin.zeroize();
 
-            let mut master_key = dec_master_key(
+            let master_key = dec_master_key(
                 v0.content.enc_master_key_pazzle,
                 &pazzle_key,
                 v0.content.master_nonce,
@@ -259,7 +335,7 @@ pub fn open_wallet_with_pazzle(
 
             Ok(EncryptedWallet::V0(dec_encrypted_block(
                 v0.content.encrypted,
-                &mut master_key,
+                master_key,
                 v0.content.peer_id,
                 v0.content.nonce,
                 v0.content.timestamp,
@@ -287,7 +363,7 @@ pub fn open_wallet_with_mnemonic(
             mnemonic.zeroize();
             pin.zeroize();
 
-            let mut master_key = dec_master_key(
+            let master_key = dec_master_key(
                 v0.content.enc_master_key_mnemonic,
                 &mnemonic_key,
                 v0.content.master_nonce,
@@ -297,7 +373,7 @@ pub fn open_wallet_with_mnemonic(
 
             Ok(EncryptedWallet::V0(dec_encrypted_block(
                 v0.content.encrypted,
-                &mut master_key,
+                master_key,
                 v0.content.peer_id,
                 v0.content.nonce,
                 v0.content.timestamp,
@@ -497,7 +573,7 @@ pub async fn create_wallet_v0(
     let user = site.site_key.to_pub();
 
     // Creating a new client
-    let client = ClientV0::new(user);
+    let client = ClientV0::new_with_auto_open(user);
 
     let create_op = WalletOpCreateV0 {
         wallet_privkey: wallet_privkey.clone(),
diff --git a/ng-wallet/src/types.rs b/ng-wallet/src/types.rs
index 3b81da5..ef463d0 100644
--- a/ng-wallet/src/types.rs
+++ b/ng-wallet/src/types.rs
@@ -17,7 +17,9 @@ use serde::{Deserialize, Serialize};
 use serde_big_array::BigArray;
 
 use p2p_net::types::*;
+use p2p_repo::errors::NgError;
 use p2p_repo::types::*;
+use p2p_repo::utils::{now_timestamp, sign};
 
 /// WalletId is a PubKey
 pub type WalletId = PubKey;
@@ -79,6 +81,17 @@ impl SessionWalletStorageV0 {
             users: HashMap::new(),
         }
     }
+    pub fn get_first_user_peer_nonce(&self) -> Result<(PubKey, u64), NgWalletError> {
+        if self.users.len() > 1 {
+            panic!("get_first_user_peer_nonce does not work as soon as there are more than one user in SessionWalletStorageV0")
+        };
+        let first = self.users.values().next();
+        if first.is_none() {
+            return Err(NgWalletError::InternalError);
+        }
+        let sps = first.unwrap();
+        Ok((sps.peer_key.to_pub(), sps.last_wallet_nonce))
+    }
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
@@ -107,6 +120,16 @@ impl From<&CreateWalletResultV0> for LocalWalletStorageV0 {
     }
 }
 
+impl LocalWalletStorageV0 {
+    pub fn new(wallet: Wallet, client: ClientV0) -> Self {
+        LocalWalletStorageV0 {
+            bootstrap: BootstrapContent::V0(BootstrapContentV0 { servers: vec![] }),
+            wallet,
+            client: client.priv_key.to_pub(),
+        }
+    }
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub enum LocalWalletStorage {
     V0(HashMap<String, LocalWalletStorageV0>),
@@ -143,13 +166,21 @@ impl ClientV0 {
         }
     }
 
-    pub fn new(user: PubKey) -> Self {
+    pub fn new_with_auto_open(user: PubKey) -> Self {
         ClientV0 {
             priv_key: PrivKey::random_ed(),
             storage_master_key: SymKey::random(),
             auto_open: vec![Identity::IndividualSite(user)],
         }
     }
+
+    pub fn new() -> Self {
+        ClientV0 {
+            priv_key: PrivKey::random_ed(),
+            storage_master_key: SymKey::random(),
+            auto_open: vec![],
+        }
+    }
 }
 
 /// Save to nextgraph.one
@@ -199,9 +230,39 @@ pub struct EncryptedWalletV0 {
     /// the format of the byte array (value) is up to the vendor, to serde as needed.
     #[zeroize(skip)]
     pub third_parties: HashMap<String, Vec<u8>>,
+
+    #[zeroize(skip)]
+    pub log: Option<WalletLogV0>,
+
+    pub master_key: Option<[u8; 32]>,
 }
 
 impl EncryptedWalletV0 {
+    pub fn import(
+        &mut self,
+        previous_wallet: Wallet,
+        session: SessionWalletStorageV0,
+    ) -> Result<(Wallet, ClientV0), NgWalletError> {
+        if self.log.is_none() {
+            return Err(NgWalletError::InternalError);
+        }
+        // Creating a new client
+        let client = ClientV0::new_with_auto_open(self.personal_site);
+        self.add_client(client.clone());
+        let mut log = self.log.as_mut().unwrap();
+        log.add(WalletOperation::SetClientV0(client.clone()));
+        let (peer_id, nonce) = session.get_first_user_peer_nonce()?;
+        Ok((
+            previous_wallet.encrypt(
+                &WalletLog::V0(log.clone()),
+                self.master_key.as_ref().unwrap(),
+                peer_id,
+                nonce,
+                self.wallet_privkey.clone(),
+            )?,
+            client,
+        ))
+    }
     pub fn add_site(&mut self, site: SiteV0) {
         let site_id = site.site_key.to_pub();
         let _ = self.sites.insert(site_id.to_string(), site);
@@ -312,11 +373,12 @@ impl WalletLogV0 {
     }
 
     /// applies all the operation and produces an encrypted wallet object.
-    pub fn reduce(&self) -> Result<EncryptedWalletV0, NgWalletError> {
+    pub fn reduce(self, master_key: [u8; 32]) -> Result<EncryptedWalletV0, NgWalletError> {
         if self.log.len() < 1 {
             Err(NgWalletError::NoCreateWalletPresent)
         } else if let (_, WalletOperation::CreateWalletV0(create_op)) = &self.log[0] {
             let mut wallet: EncryptedWalletV0 = create_op.into();
+            wallet.master_key = Some(master_key);
 
             for op in &self.log {
                 match &op.1 {
@@ -420,6 +482,7 @@ impl WalletLogV0 {
                 }
             }
             log_debug!("reduced {:?}", wallet);
+            wallet.log = Some(self);
             Ok(wallet)
         } else {
             Err(NgWalletError::NoCreateWalletPresent)
@@ -661,6 +724,8 @@ impl From<&WalletOpCreateV0> for EncryptedWalletV0 {
             clients: HashMap::new(),
             overlay_core_overrides: HashMap::new(),
             third_parties: HashMap::new(),
+            log: None,
+            master_key: None,
         };
         wallet.add_site(op.personal_site.clone());
         //wallet.add_brokers(op.brokers.clone());
@@ -757,29 +822,6 @@ pub enum Wallet {
     V0(WalletV0),
 }
 
-impl Wallet {
-    pub fn id(&self) -> WalletId {
-        match self {
-            Wallet::V0(v0) => v0.id,
-        }
-    }
-    pub fn content_as_bytes(&self) -> Vec<u8> {
-        match self {
-            Wallet::V0(v0) => serde_bare::to_vec(&v0.content).unwrap(),
-        }
-    }
-    pub fn sig(&self) -> Sig {
-        match self {
-            Wallet::V0(v0) => v0.sig,
-        }
-    }
-    pub fn pazzle_length(&self) -> u8 {
-        match self {
-            Wallet::V0(v0) => v0.content.pazzle_length,
-        }
-    }
-}
-
 /// Add Wallet Version 0
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct AddWalletV0 {
@@ -915,6 +957,7 @@ impl fmt::Display for NgWalletError {
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub enum NgFileV0 {
     Wallet(Wallet),
+    Other,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
@@ -922,6 +965,14 @@ pub enum NgFile {
     V0(NgFileV0),
 }
 
+impl TryFrom<Vec<u8>> for NgFile {
+    type Error = NgError;
+    fn try_from(file: Vec<u8>) -> Result<Self, Self::Error> {
+        let ngf: Self = serde_bare::from_slice(&file).map_err(|_| NgError::InvalidFileFormat)?;
+        Ok(ngf)
+    }
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct ShuffledPazzle {
     pub category_indices: Vec<u8>,
diff --git a/p2p-repo/src/errors.rs b/p2p-repo/src/errors.rs
index fddc8bd..0161c02 100644
--- a/p2p-repo/src/errors.rs
+++ b/p2p-repo/src/errors.rs
@@ -22,6 +22,7 @@ pub enum NgError {
     InvalidKey,
     InvalidInvitation,
     InvalidCreateAccount,
+    InvalidFileFormat,
 }
 
 impl Error for NgError {}