oddsdk · avivash · Jan 13, 2023 · Jan 12, 2023 · Jan 12, 2023 · Jan 12, 2023
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Changelog
 
+### v0.36.0
+
+Adds `program.recoverFileSystem({ newUsername, oldUsername, readKey })` shorthand method so apps will no longer have to implement the FS recovery flow manually.
+
 ### v0.35.2
 
 Fixes issue with the types of the `path.appData` function. Now has the correct overloads.
@@ -354,7 +358,7 @@ Upgrade to CIDv1.
   });
   ```
 
-- Those prerequisites are passed to the `wn.redirectToLobby` function.  
+- Those prerequisites are passed to the `wn.redirectToLobby` function.
   (So the auth lobby has the correct parameters to determine the permissions to ask the user)
 - Adds the ability to use multiple apps with one file system (closes #73)
 - The SDK now handles multiple UCANs

diff --git a/README.md b/README.md
@@ -142,6 +142,7 @@ __Notes:__
 - You can use alternative authentication strategies, such as [webnative-walletauth](https://github.com/fission-codes/webnative-walletauth).
 - You can remove all traces of the user using `await session.destroy()`
 - You can load the file system separately if you're using a web worker. This is done using the combination of `configuration.fileSystem.loadImmediately = false` and `program.loadFileSystem()`
+- You can recover a file system if you've downloaded a Recovery Kit by calling `program.recoverFileSystem({ newUsername, oldUsername, readKey })`. The `oldUsername` and `readKey` can be parsed from the uploaded Recovery Kit and the `newUsername` can be generated before calling the function. Please refer to [this example](https://github.com/webnativ
10000
e-examples/webnative-app-template/blob/5498e7062a4578028b8b55d2ac4c611bd5daab85/src/components/auth/recover/HasRecoveryKit.svelte#L49) from Fission's Webnative App Template. Additionally, if you would like to see how to generate a Recovery Kit, you can reference [this example](https://github.com/webnative-examples/webnative-app-template/blob/main/src/lib/account-settings.ts#L186)
 
 
 ## Working with the file system

diff --git a/src/filesystem.ts b/src/filesystem.ts
@@ -1,16 +1,23 @@
 import { CID } from "multiformats/cid"
 
+import * as Crypto from "./components/crypto/implementation.js"
 import * as Depot from "./components/depot/implementation.js"
-import * as Reference from "./components/reference/implementation.js"
-
+import * as DID from "./did/index.js"
 import * as Protocol from "./fs/protocol/index.js"
+import * as Reference from "./components/reference/implementation.js"
+import * as RootKey from "./common/root-key.js"
+import * as Storage from "./components/storage/implementation.js"
+import * as Ucan from "./ucan/index.js"
 import * as Versions from "./fs/versions.js"
 
-import FileSystem, { Dependencies } from "./fs/filesystem.js"
-
+import { AuthenticationStrategy } from "./index.js"
 import { Branch } from "./path/index.js"
 import { Configuration } from "./configuration.js"
+import { Dependencies } from "./fs/filesystem.js"
 import { Maybe, decodeCID, EMPTY_CID } from "./common/index.js"
+import { type RecoverFileSystemParams } from "./fs/types/params.js"
+
+import FileSystem from "./fs/filesystem.js"
 
 
 /**
@@ -105,6 +112,67 @@ export async function loadFileSystem({ config, dependencies, rootKey, username }
   return fs
 }
 
+/**
+ * Recover a user's file system.
+ */
+export async function recoverFileSystem({
+  auth,
+  dependencies,
+  oldUsername,
+  newUsername,
+  readKey,
+}: {
+  auth: AuthenticationStrategy
+  dependencies: {
+    crypto: Crypto.Implementation
+    reference: Reference.Implementation
+    storage: Storage.Implementation
+  }
+} & RecoverFileSystemParams): Promise<{ success: boolean }> {
+
+  const { crypto, reference, storage } = dependencies
+
+  const newRootDID = await DID.agent(crypto)
+
+  // Register a new user with the `newUsername`
+  const { success } = await auth.register({
+    username: newUsername,
+  })
+  if (!success) {
+    throw new Error("Failed to register new user")
+  }
+
+  // Build an ephemeral UCAN to authorize the dataRoot.update call
+  const proof: string | null = await storage.getItem(storage.KEYS.ACCOUNT_UCAN)
+  const ucan = await Ucan.build({
+    dependencies,
+    potency: "APPEND",
+    resource: "*",
+    proof: proof ? proof : undefined,
+    lifetimeInSeconds: 60 * 3, // Three minutes
+    audience: newRootDID,
+    issuer: newRootDID,
+  })
+
+  const oldRootCID = await reference.dataRoot.lookup(oldUsername)
+  if (!oldRootCID) {
+    throw new Error("Failed to lookup oldUsername")
+  }
+
+  // Update the dataRoot of the new user
+  await reference.dataRoot.update(oldRootCID, ucan)
+
+  // Store the read key, which is namespaced using the account DID
+  await RootKey.store({
+    accountDID: newRootDID,
+    crypto: crypto,
+    readKey,
+  })
+
+  return {
+    success: true,
+  }
+}
 
 
 // VERSIONING
@@ -209,4 +277,4 @@ async function getDataRoot(
       resolve(dataCid?.toString() === EMPTY_CID ? null : dataCid)
     }, retryInterval)
   })
-}
+}
diff --git a/src/fs/types/params.ts b/src/fs/types/params.ts
@@ -0,0 +1,5 @@
+export type RecoverFileSystemParams = {
+  newUsername: string
+  oldUsername: string
+  readKey: Uint8Array
+}
diff --git a/src/index.ts b/src/index.ts
@@ -49,12 +49,19 @@ import { Components } from "./components.js"
 import { Configuration, namespace } from "./configuration.js"
 import { isString, Maybe } from "./common/index.js"
 import { Session } from "./session.js"
-import { loadFileSystem } from "./filesystem.js"
+import { loadFileSystem, recoverFileSystem } from "./filesystem.js"
 import FileSystem from "./fs/filesystem.js"
 
 
+// TYPES
+
+
+import { type RecoverFileSystemParams } from "./fs/types/params.js"
+
+
 // IMPLEMENTATIONS
 
+
 import * as BaseAuth from "./components/auth/implementation/base.js"
 import * as BaseReference from "./components/reference/implementation/base.js"
 import * as BrowserCrypto from "./components/crypto/implementation/browser.js"
@@ -143,9 +150,13 @@ export enum ProgramError {
   UnsupportedBrowser = "UNSUPPORTED_BROWSER"
 }
 
-
 export type ShortHands = {
   loadFileSystem: (username: string) => Promise<FileSystem>
+  recoverFileSystem: ({
+    newUsername,
+    oldUsername,
+    readKey,
+  }: RecoverFileSystemParams) => Promise<{ success: boolean }>
   agentDID: () => Promise<string>
   sharingDID: () => Promise<string>
 }
@@ -485,8 +496,14 @@ export async function assemble(config: Configuration, components: Components): P
 
   // Shorthands
   const shorthands: ShortHands = {
-    loadFileSystem: (username: string) => loadFileSystem({ config, username, dependencies: components }),
-
+    loadFileSystem: (username: string) =>
+      loadFileSystem({ config, username, dependencies: components }),
+    recoverFileSystem: (params: RecoverFileSystemParams) =>
+      recoverFileSystem({
+        auth,
+        dependencies: { crypto: components.crypto, reference: components.reference, storage: components.storage },
+        ...params,
+      }),
     agentDID: () => DID.agent(components.crypto),
     sharingDID: () => DID.sharing(components.crypto),
   }