feat: vault migrations

apps/extension/src/background/vault/service.ts

@@ -18,9 +18,11 @@ export class VaultService {
   ) {}
 
   public async initialize(): Promise<void> {
-    const storage = await this.vaultStorage.get();
-    if (!storage) {
+    const exists = await this.vaultStorage.exists();
+    if (!exists) {
       await this.vaultStorage.reset();
+    } else {
+      await this.vaultStorage.migrate();
     }
   }
 

apps/extension/src/provider/data.mock.ts

@@ -3,7 +3,7 @@ import { KdfType } from "@namada/sdk/web";
 import { AccountType, BridgeType, Chain, Extensions } from "@namada/types";
 import { ActiveAccountStore } from "background/keyring";
 import { Vault } from "background/vault";
-import { VaultTypes } from "storage";
+import { KeyStoreType } from "storage";
 
 export const ACTIVE_ACCOUNT: ActiveAccountStore = {
   id: "324bfe0e-cb19-5f1a-9630-9daaaecadabe",
@@ -30,7 +30,7 @@ export const chain: Chain = {
   },
 };
 
-export const keyStore: Vault<VaultTypes>[] = [
+export const keyStore: Vault<KeyStoreType>[] = [
   {
     public: {
       alias: "Parent Account",

apps/extension/src/storage/VaultStorage.test.ts

@@ -1,7 +1,8 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { AccountType } from "@namada/types";
 import { KVStoreMock } from "test/init";
-import { KeyStore, VaultStorage } from "./VaultStorage";
+import { VaultStorage } from "./VaultStorage";
+import { KeyStore } from "./schemas";
 
 jest.mock("webextension-polyfill", () => ({}));
 
@@ -40,7 +41,7 @@ const addNonSensitiveData = async (
 ): Promise<void> => {
   await vaultStorage.set({
     data: {
-      test: [
+      "key-store": [
         {
           public: {
             id: `${id}`,

apps/extension/src/storage/VaultStorage.ts

@@ -2,116 +2,19 @@ import { KVStore } from "@namada/storage";
 import * as E from "fp-ts/Either";
 import * as t from "io-ts";
 import { ExtStorage } from "./Storage";
+import {
+  KeyStore,
+  KeyStoreType,
+  migrateVault,
+  SensitiveType,
+  Vault,
+  VaultType,
+} from "./schemas";
 
 export type PrimitiveType = string | number | boolean;
 
-const Uint8ArrayCodec = new t.Type<Uint8Array, Uint8Array, unknown>(
-  "Uint8Array",
-  (u): u is Uint8Array => u instanceof Uint8Array,
-  (u, c) => {
-    try {
-      const a = Array.from(u as Uint8Array);
-      return t.success(Uint8Array.from(a));
-    } catch {
-      return t.failure(u, c);
-    }
-  },
-  t.identity
-);
-
-enum KdfType {
-  Argon2 = "argon2",
-  Scrypt = "scrypt",
-}
-
-export const Sensitive = t.type({
-  cipher: t.type({
-    type: t.literal("aes-256-gcm"),
-    iv: Uint8ArrayCodec,
-    text: Uint8ArrayCodec,
-  }),
-  kdf: t.type({
-    type: t.keyof({
-      [KdfType.Argon2]: null,
-      [KdfType.Scrypt]: null,
-    }),
-    params: t.any,
-  }),
-});
-export type SensitiveType = t.TypeOf<typeof Sensitive>;
-
-enum AccountType {
-  Mnemonic = "mnemonic",
-  PrivateKey = "private-key",
-  ShieldedKeys = "shielded-keys",
-  Ledger = "ledger",
-}
-
-export const KeyStore = t.exact(
-  t.intersection([
-    t.type({
-      id: t.string,
-      alias: t.string,
-      address: t.string,
-      owner: t.string,
-      path: t.intersection([
-        t.type({
-          account: t.number,
-        }),
-        t.partial({
-          change: t.number,
-          index: t.number,
-        }),
-      ]),
-      type: t.keyof({
-        [AccountType.Mnemonic]: null,
-        [AccountType.PrivateKey]: null,
-        [AccountType.ShieldedKeys]: null,
-        [AccountType.Ledger]: null,
-      }),
-      source: t.keyof({
-        imported: null,
-        generated: null,
-      }),
-      timestamp: t.number,
-    }),
-    t.partial({
-      publicKey: t.string,
-      parentId: t.string,
-      pseudoExtendedKey: t.string,
-    }),
-  ])
-);
-export type KeyStoreType = t.TypeOf<typeof KeyStore>;
-
-const Vault = t.intersection([
-  t.type({
-    data: t.record(
-      t.string,
-      t.array(
-        t.intersection([
-          t.type({
-            public: KeyStore,
-          }),
-          t.partial({
-            sensitive: Sensitive,
-          }),
-        ])
-      )
-    ),
-  }),
-  t.partial({
-    password: Sensitive,
-  }),
-]);
-
-type VaultType = t.TypeOf<typeof Vault>;
-
-export type VaultTypes = KeyStoreType;
-
-export type VaultSchemas = typeof KeyStore;
-
 export type VaultKeys = "key-store";
+export type VaultSchemas = typeof KeyStore;
 
 export const schemasMap = new Map<VaultSchemas, VaultKeys>([
   [KeyStore, "key-store"],
@@ -122,6 +25,12 @@ export class VaultStorage extends ExtStorage {
     super(provider);
   }
 
+  public async migrate(): Promise<void> {
+    const data = await this.getRaw("vault");
+    const newData = migrateVault(data);
+    await this.set(newData);
+  }
+
   public validate(data: unknown): VaultType {
     const decodedData = Vault.decode(data);
 
@@ -144,6 +53,11 @@ export class VaultStorage extends ExtStorage {
     return decoded.right;
   }
 
+  public async exists(): Promise<boolean> {
+    const data = await this.getRaw("vault");
+    return !this.isEmpty(data);
+  }
+
   public async getOrFail(): Promise<VaultType> {
     const storedData = await this.get();
     if (!storedData) {
@@ -217,7 +131,7 @@ export class VaultStorage extends ExtStorage {
     schema: S,
     prop: keyof t.TypeOf<S>,
     value: string,
-    newProps: Partial<VaultTypes>
+    newProps: Partial<KeyStoreType>
   ): Promise<t.TypeOf<S>> {
     const accountIdx = await this.findIndexOrFail(schema, prop, value);
     const storedData = await this.getSpecificOrFail(schema);
@@ -230,7 +144,7 @@ export class VaultStorage extends ExtStorage {
 
   public async remove<S extends VaultSchemas>(
     schema: S,
-    prop: keyof VaultTypes,
+    prop: keyof KeyStoreType,
     value: PrimitiveType
   ): Promise<{ public: t.TypeOf<S> }[]> {
     const storedData = (await this.getSpecific(schema)) || [];
@@ -334,4 +248,9 @@ export class VaultStorage extends ExtStorage {
 
     return key;
   }
+
+  private isEmpty(data: unknown): boolean {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return Object.keys((data as any)?.data || {}).length === 0;
+  }
 }

apps/extension/src/storage/index.ts

@@ -1,2 +1,3 @@
 export * from "./LocalStorage";
+export * from "./schemas";
 export * from "./VaultStorage";

apps/extension/src/storage/schemas/VaultSchemaV1.ts

@@ -0,0 +1,94 @@
+import * as t from "io-ts";
+
+const Uint8ArrayCodec = new t.Type<Uint8Array, Uint8Array, unknown>(
+  "Uint8Array",
+  (u): u is Uint8Array => u instanceof Uint8Array,
+  (u, c) => {
+    try {
+      const a = Array.from(u as Uint8Array);
+      return t.success(Uint8Array.from(a));
+    } catch {
+      return t.failure(u, c);
+    }
+  },
+  t.identity
+);
+
+enum KdfType {
+  Argon2 = "argon2",
+  Scrypt = "scrypt",
+}
+
+export const Sensitive = t.type({
+  cipher: t.type({
+    type: t.literal("aes-256-gcm"),
+    iv: Uint8ArrayCodec,
+    text: Uint8ArrayCodec,
+  }),
+  kdf: t.type({
+    type: t.keyof({
+      [KdfType.Argon2]: null,
+      [KdfType.Scrypt]: null,
+    }),
+    params: t.any,
+  }),
+});
+
+enum AccountType {
+  Mnemonic = "mnemonic",
+  PrivateKey = "private-key",
+  ShieldedKeys = "shielded-keys",
+  Ledger = "ledger",
+}
+
+export const KeyStore = t.exact(
+  t.intersection([
+    t.type({
+      id: t.string,
+      alias: t.string,
+      address: t.string,
+      owner: t.string,
+      path: t.intersection([
+        t.type({
+          account: t.number,
+        }),
+        t.partial({
+          change: t.number,
+          index: t.number,
+        }),
+      ]),
+      type: t.keyof({
+        [AccountType.Mnemonic]: null,
+        [AccountType.PrivateKey]: null,
+        [AccountType.ShieldedKeys]: null,
+        [AccountType.Ledger]: null,
+      }),
+    }),
+    t.partial({
+      publicKey: t.string,
+      parentId: t.string,
+      pseudoExtendedKey: t.string,
+    }),
+  ])
+);
+
+export const Vault = t.intersection([
+  t.type({
+    data: t.record(
+      t.string,
+      t.array(
+        t.intersection([
+          t.type({
+            public: KeyStore,
+          }),
+          t.partial({
+            sensitive: Sensitive,
+          }),
+        ])
+      )
+    ),
+  }),
+  t.partial({
+    password: Sensitive,
+  }),
+]);