Update db

src/service-workers/database.worker.js

@@ -16,29 +16,18 @@ self.addEventListener('message', async (event) => {
       const db = await openDatabase();
       const tx = db.transaction(storeName, 'readwrite');
       const store = tx.objectStore(storeName);
-      await store.put({
+
-        ...object,
+      if (key) {
-        modified: Date.now()
+        await store.put(object, key);
-      });
+      } else {
-      event.ports[0].postMessage({ status: 'success', message: 'Object added or replaced successfully' });
+        await store.put(object);
+      }
+
+      event.ports[0].postMessage({ status: 'success', message: '' });
     } catch (error) {
       event.ports[0].postMessage({ status: 'error', message: error.message });
     }
   }
-
-  if (data.type === 'GET_OBJECT') {
-    const { storeName, key } = data.payload;
-    const db = await openDatabase();
-    const tx = db.transaction(storeName, 'readonly');
-    const store = tx.objectStore(storeName);
-    const result = await new Promise((resolve, reject) => {
-      const getRequest = store.get(key);
-      getRequest.onsuccess = (event) => resolve(getRequest.result);
-      getRequest.onerror = (event) => reject(getRequest.error);
-    });
-
-    event.ports[0].postMessage({ type: 'GET_OBJECT_RESULT', payload: result });
-  }
 });
 
 async function openDatabase() {

src/services/database.service.ts

@@ -17,9 +17,14 @@ class Database {
       options: { keyPath: 'id' },
       indices: [],
     },
-    AnkMessages: {
+    AnkSharedSecrets: {
-      name: 'messages',
+      name: 'shared_secrets',
-      options: { keyPath: 'id' },
+      options: { keyPath: 'key' },
+      indices: [],
+    },
+    AnkUnconfirmedSecrets: {
+      name: 'unconfirmed_secrets',
+      options: { autoIncrement: true },
       indices: [],
     },
     AnkProcessData: {
@@ -139,50 +144,52 @@ class Database {
     console.log('Received response from service worker (GET_OBJECT):', event.data);
   };
 
-  public async addObject(payload: { storeName: string; object: any; key: any }) {
+  public addObject(payload: { storeName: string; object: any; key: any }): Promise<void> {
-    if (this.serviceWorkerRegistration?.active) {
+    return new Promise((resolve, reject) => {
-      const messageChannel = this.createMessageChannel(this.handleAddObjectResponse);
+      // Check if the service worker is active
-      this.serviceWorkerRegistration.active.postMessage(
+      if (!this.serviceWorkerRegistration?.active) {
-        {
+        reject(new Error('Service worker is not active'));
-          type: 'ADD_OBJECT',
+        return;
-          payload,
+      }
-        },
+
-        [messageChannel.port2],
+      // Create a message channel for communication
-      );
+      const messageChannel = new MessageChannel();
-    } else {
+
-      const { storeName, object } = payload;
+      // Handle the response from the service worker
-      const db = await openDatabase();
+      messageChannel.port1.onmessage = (event) => {
-      const tx = db.transaction(storeName, 'readwrite');
+        if (event.data.status === 'success') {
-      const store = tx.objectStore(storeName);
+          resolve();
-      await store.put({
+        } else {
-        ...object,
+          const error = event.data.message;
-        modified: Date.now()
+          reject(new Error(error || 'Unknown error occurred while adding object'));
-      });
+        }
-    }
+      };
+
+      // Send the add object request to the service worker
+      try {
+        this.serviceWorkerRegistration.active.postMessage(
+          {
+            type: 'ADD_OBJECT',
+            payload,
+          },
+          [messageChannel.port2],
+        );
+      } catch (error) {
+        reject(new Error(`Failed to send message to service worker: ${error}`));
+      }
+    });
   }
 
-  public async getObject(storeName: string, key: string) {
+  public async getObject(storeName: string, key: string): Promise<any | null> {
-    if (this.serviceWorkerRegistration?.active) {
+    const db = await this.getDb();
-      const messageChannel = this.createMessageChannel(this.handleGetObjectResponse);
+    const tx = db.transaction(storeName, 'readonly');
-
+    const store = tx.objectStore(storeName);
-      this.serviceWorkerRegistration.active.postMessage(
+    const result = await new Promise((resolve, reject) => {
-        {
+      const getRequest = store.get(key);
-          type: 'GET_OBJECT',
+      getRequest.onsuccess = () => resolve(getRequest.result);
-          payload: { storeName, key },
+      getRequest.onerror = () => reject(getRequest.error);
-        },
+    });
-        [messageChannel.port2],
+    return result
-      );
-    } else {
-      const db = await openDatabase();
-      const tx = db.transaction(storeName, 'readonly');
-      const store = tx.objectStore(storeName);
-      const result = await new Promise((resolve, reject) => {
-        const getRequest = store.get(key);
-        getRequest.onsuccess = () => resolve(getRequest.result);
-        getRequest.onerror = () => reject(getRequest.error);
-      });
-      console.log("🚀 ~ Database ~ result ~ result:", result)
-    }
   }
 }
 

src/services/service.ts

@@ -297,18 +297,30 @@ export default class Services {
 
   async saveDevice(device: any): Promise<any> {
     const db = await Database.getInstance();
-    db.addObject({
+    try {
-      storeName: 'wallet',
+      await db.addObject({
-      object: { pre_id: '1', device },
+        storeName: 'wallet',
-      key: '1',
+        object: { pre_id: '1', device },
-    });
+        key: null,
-    localStorage.setItem('wallet', device);
+      });
+    } catch (e) {
+      console.error(e);
+    }
   }
 
   async getDevice(): Promise<string | null> {
     const db = await Database.getInstance();
-    db.getObject('wallet', '1');
+    try {
-    return localStorage.getItem('wallet');
+      const dbRes = await db.getObject('wallet', '1');
+      if (dbRes) {
+        const wallet = dbRes['device'];
+        return wallet;
+      } else {
+        return null;
+      }
+    } catch (e) {
+      throw new Error(`Failed to retrieve device from db: ${e}`);
+    }
   }
 
   async dumpWallet() {