4nk/ihm_client
5
0
Fork 0
Code Issues 6 Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(database): remove obsolete database.worker.js and update database service to utilize Web Worker for IndexedDB operations

Browse Source
This commit is contained in:
NicolasCantu 2025-11-27 23:20:53 +01:00
parent 90376e364a
commit d45cf7c530
11 changed files with 965 additions and 684 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

152
public/data.worker.js Normal file
View File

@ -0,0 +1,152 @@
const EMPTY32BYTES = String('').padStart(64, '0');
// ============================================
// SERVICE WORKER LIFECYCLE
// ============================================
self.addEventListener('install', (event) => {
event.waitUntil(self.skipWaiting());
});
self.addEventListener('activate', (event) => {
event.waitUntil(self.clients.claim());
});
// ============================================
// MESSAGE HANDLER
// ============================================
self.addEventListener('message', async (event) => {
const data = event.data;
console.log('[Service Worker] Message received:', data.type);
if (data.type === 'SCAN') {
try {
const myProcessesId = data.payload;
if (myProcessesId && myProcessesId.length != 0) {
const scanResult = await scanMissingData(myProcessesId, event.source);
if (scanResult.toDownload.length != 0) {
console.log('[Service Worker] Sending TO_DOWNLOAD message');
event.source.postMessage({ type: 'TO_DOWNLOAD', data: scanResult.toDownload });
}
if (scanResult.diffsToCreate.length > 0) {
console.log('[Service Worker] Sending DIFFS_TO_CREATE message');
event.source.postMessage({ type: 'DIFFS_TO_CREATE', data: scanResult.diffsToCreate });
}
} else {
event.source.postMessage({ status: 'error', message: 'Empty lists' });
}
} catch (error) {
console.error('[Service Worker] Scan error:', error);
event.source.postMessage({ status: 'error', message: error.message });
}
}
});
// ============================================
// DATABASE COMMUNICATION
// ============================================
async function requestFromMainThread(client, action, payload) {
return new Promise((resolve, reject) => {
const messageId = `sw_${Date.now()}_${Math.random()}`;
const messageHandler = (event) => {
if (event.data.id === messageId) {
self.removeEventListener('message', messageHandler);
if (event.data.type === 'DB_RESPONSE') {
resolve(event.data.result);
} else if (event.data.type === 'DB_ERROR') {
reject(new Error(event.data.error));
}
}
};
self.addEventListener('message', messageHandler);
client.postMessage({
type: 'DB_REQUEST',
id: messageId,
action,
payload
});
setTimeout(() => {
self.removeEventListener('message', messageHandler);
reject(new Error('Database request timeout'));
}, 10000);
});
}
// ============================================
// SCAN LOGIC
// ============================================
async function scanMissingData(processesToScan, client) {
console.log('[Service Worker] Scanning for missing data...');
const myProcesses = await requestFromMainThread(client, 'GET_MULTIPLE_OBJECTS', {
storeName: 'processes',
keys: processesToScan
});
let toDownload = new Set();
let diffsToCreate = [];
if (myProcesses && myProcesses.length != 0) {
for (const process of myProcesses) {
const firstState = process.states[0];
const processId = firstState.commited_in;
for (const state of process.states) {
if (state.state_id === EMPTY32BYTES) continue;
for (const [field, hash] of Object.entries(state.pcd_commitment)) {
if (state.public_data[field] !== undefined || field === 'roles') continue;
const existingData = await requestFromMainThread(client, 'GET_OBJECT', {
storeName: 'data',
key: hash
});
if (!existingData) {
toDownload.add(hash);
const existingDiff = await requestFromMainThread(client, 'GET_OBJECT', {
storeName: 'diffs',
key: hash
});
if (!existingDiff) {
diffsToCreate.push({
process_id: processId,
state_id: state.state_id,
value_commitment: hash,
roles: state.roles,
field: field,
description: null,
previous_value: null,
new_value: null,
notify_user: false,
need_validation: false,
validation_status: 'None'
});
}
} else {
if (toDownload.delete(hash)) {
console.log(`[Service Worker] Removing ${hash} from the set`);
}
}
}
}
}
}
console.log('[Service Worker] Scan complete:', { toDownload: toDownload.size, diffsToCreate: diffsToCreate.length });
return {
toDownload: Array.from(toDownload),
diffsToCreate: diffsToCreate
};
}

281
public/database.worker.js
View File

@ -1,281 +0,0 @@
const EMPTY32BYTES = String('').padStart(64, '0');
self.addEventListener('install', (event) => {
event.waitUntil(self.skipWaiting()); // Activate worker immediately
});
self.addEventListener('activate', (event) => {
event.waitUntil(self.clients.claim()); // Become available to all pages
});
// Event listener for messages from clients
self.addEventListener('message', async (event) => {
const data = event.data;
console.log(data);
if (data.type === 'SCAN') {
try {
const myProcessesId = data.payload;
if (myProcessesId && myProcessesId.length != 0) {
const toDownload = await scanMissingData(myProcessesId);
if (toDownload.length != 0) {
console.log('Sending TO_DOWNLOAD message');
event.source.postMessage({ type: 'TO_DOWNLOAD', data: toDownload});
}
} else {
event.source.postMessage({ status: 'error', message: 'Empty lists' });
}
} catch (error) {
event.source.postMessage({ status: 'error', message: error.message });
}
} else if (data.type === 'ADD_OBJECT') {
try {
const { storeName, object, key } = data.payload;
const db = await openDatabase();
const tx = db.transaction(storeName, 'readwrite');
const store = tx.objectStore(storeName);
if (key) {
await store.put(object, key);
} else {
await store.put(object);
}
event.ports[0].postMessage({ status: 'success', message: '' });
} catch (error) {
event.ports[0].postMessage({ status: 'error', message: error.message });
}
} else if (data.type === 'BATCH_WRITING') {
const { storeName, objects } = data.payload;
const db = await openDatabase();
const tx = db.transaction(storeName, 'readwrite');
const store = tx.objectStore(storeName);
for (const { key, object } of objects) {
if (key) {
await store.put(object, key);
} else {
await store.put(object);
}
}
await tx.done;
}
});
async function scanMissingData(processesToScan) {
console.log('Scanning for missing data...');
const myProcesses = await getProcesses(processesToScan);
let toDownload = new Set();
// Iterate on each process
if (myProcesses && myProcesses.length != 0) {
for (const process of myProcesses) {
// Iterate on states
const firstState = process.states[0];
const processId = firstState.commited_in;
for (const state of process.states) {
if (state.state_id === EMPTY32BYTES) continue;
// iterate on pcd_commitment
for (const [field, hash] of Object.entries(state.pcd_commitment)) {
// Skip public fields
if (state.public_data[field] !== undefined || field === 'roles') continue;
// Check if we have the data in db
const existingData = await getBlob(hash);
if (!existingData) {
toDownload.add(hash);
// We also add an entry in diff, in case it doesn't already exist
await addDiff(processId, state.state_id, hash, state.roles, field);
} else {
// We remove it if we have it in the set
if (toDownload.delete(hash)) {
console.log(`Removing ${hash} from the set`);
}
}
}
}
}
}
console.log(toDownload);
return Array.from(toDownload);
}
async function openDatabase() {
return new Promise((resolve, reject) => {
const request = indexedDB.open('4nk', 1);
request.onerror = (event) => {
reject(request.error);
};
request.onsuccess = (event) => {
resolve(request.result);
};
request.onupgradeneeded = (event) => {
const db = event.target.result;
if (!db.objectStoreNames.contains('wallet')) {
db.createObjectStore('wallet', { keyPath: 'pre_id' });
}
};
});
}
// Function to get all processes because it is asynchronous
async function getAllProcesses() {
const db = await openDatabase();
return new Promise((resolve, reject) => {
if (!db) {
reject(new Error('Database is not available'));
return;
}
const tx = db.transaction('processes', 'readonly');
const store = tx.objectStore('processes');
const request = store.getAll();
request.onsuccess = () => {
resolve(request.result);
};
request.onerror = () => {
reject(request.error);
};
});
};
async function getProcesses(processIds) {
if (!processIds || processIds.length === 0) {
return [];
}
const db = await openDatabase();
if (!db) {
throw new Error('Database is not available');
}
const tx = db.transaction('processes', 'readonly');
const store = tx.objectStore('processes');
const requests = Array.from(processIds).map((processId) => {
return new Promise((resolve) => {
const request = store.get(processId);
request.onsuccess = () => resolve(request.result);
request.onerror = () => {
console.error(`Error fetching process ${processId}:`, request.error);
resolve(undefined);
};
});
});
const results = await Promise.all(requests);
return results.filter(result => result !== undefined);
}
async function getAllDiffsNeedValidation() {
const db = await openDatabase();
const allProcesses = await getAllProcesses();
const tx = db.transaction('diffs', 'readonly');
const store = tx.objectStore('diffs');
return new Promise((resolve, reject) => {
const request = store.getAll();
request.onsuccess = (event) => {
const allItems = event.target.result;
const itemsWithFlag = allItems.filter((item) => item.need_validation);
const processMap = {};
for (const diff of itemsWithFlag) {
const currentProcess = allProcesses.find((item) => {
return item.states.some((state) => state.merkle_root === diff.new_state_merkle_root);
});
if (currentProcess) {
const processKey = currentProcess.merkle_root;
if (!processMap[processKey]) {
processMap[processKey] = {
process: currentProcess.states,
processId: currentProcess.key,
diffs: [],
};
}
processMap[processKey].diffs.push(diff);
}
}
const results = Object.values(processMap).map((entry) => {
const diffs = []
for(const state of entry.process) {
const filteredDiff = entry.diffs.filter(diff => diff.new_state_merkle_root === state.merkle_root);
if(filteredDiff && filteredDiff.length) {
diffs.push(filteredDiff)
}
}
return {
process: entry.process,
processId: entry.processId,
diffs: diffs,
};
});
resolve(results);
};
request.onerror = (event) => {
reject(event.target.error);
};
});
}
async function getBlob(hash) {
const db = await openDatabase();
const storeName = 'data';
const tx = db.transaction(storeName, 'readonly');
const store = tx.objectStore(storeName);
const result = await new Promise((resolve, reject) => {
const getRequest = store.get(hash);
getRequest.onsuccess = () => resolve(getRequest.result);
getRequest.onerror = () => reject(getRequest.error);
});
return result;
}
async function addDiff(processId, stateId, hash, roles, field) {
const db = await openDatabase();
const storeName = 'diffs';
const tx = db.transaction(storeName, 'readwrite');
const store = tx.objectStore(storeName);
// Check if the diff already exists
const existingDiff = await new Promise((resolve, reject) => {
const getRequest = store.get(hash);
getRequest.onsuccess = () => resolve(getRequest.result);
getRequest.onerror = () => reject(getRequest.error);
});
if (!existingDiff) {
const newDiff = {
process_id: processId,
state_id: stateId,
value_commitment: hash,
roles: roles,
field: field,
description: null,
previous_value: null,
new_value: null,
notify_user: false,
need_validation: false,
validation_status: 'None'
};
const insertResult = await new Promise((resolve, reject) => {
const putRequest = store.put(newDiff);
putRequest.onsuccess = () => resolve(putRequest.result);
putRequest.onerror = () => reject(putRequest.error);
});
return insertResult;
}
return existingDiff;
}

9
src/main.ts
View File

@ -9,13 +9,12 @@ async function bootstrap() {
console.log("🚀 Démarrage de l'application 4NK..."); console.log("🚀 Démarrage de l'application 4NK...");
try { try {
// 1. Initialisation de la Base de données // 1. Initialisation des Services (WASM, Sockets, Database...)
const db = await Database.getInstance();
db.registerServiceWorker('/database.worker.js');
// 2. Initialisation des Services (WASM, Sockets...)
const services = await Services.getInstance(); const services = await Services.getInstance();
// 2. Initialisation de la base de données (Web Worker + Service Worker)
await Database.getInstance();
// Injection du Header dans le slot prévu dans index.html // Injection du Header dans le slot prévu dans index.html
const headerSlot = document.getElementById('header-slot'); const headerSlot = document.getElementById('header-slot');
if (headerSlot) { if (headerSlot) {

2
src/services/core/network.service.ts
View File

@ -20,12 +20,10 @@ export class NetworkService {
} }
} }
// --- AJOUT ---
public async addWebsocketConnection(url: string): Promise<void> { public async addWebsocketConnection(url: string): Promise<void> {
console.log(`[Network] 🔌 Connexion à: ${url}`); console.log(`[Network] 🔌 Connexion à: ${url}`);
await initWebsocket(url); await initWebsocket(url);
} }
// -------------
public initRelays() { public initRelays() {
for (const wsurl of this.bootstrapUrls) { for (const wsurl of this.bootstrapUrls) {

605
src/services/database.service.ts
View File

@ -1,159 +1,137 @@
import Services from './service'; import Services from './service';
import { APP_CONFIG } from '../config/constants';
/**
* Database service managing IndexedDB operations via Web Worker and Service Worker
*/
export class Database { export class Database {
// ============================================
// PRIVATE PROPERTIES
// ============================================
private static instance: Database; private static instance: Database;
private db: IDBDatabase | null = null;
private dbName: string = '4nk';
private dbVersion: number = 1;
private serviceWorkerRegistration: ServiceWorkerRegistration | null = null; private serviceWorkerRegistration: ServiceWorkerRegistration | null = null;
private messageChannel: MessageChannel | null = null;
private messageChannelForGet: MessageChannel | null = null;
private serviceWorkerCheckIntervalId: number | null = null; private serviceWorkerCheckIntervalId: number | null = null;
private storeDefinitions = { private indexedDBWorker: Worker | null = null;
AnkLabels: { private messageIdCounter: number = 0;
name: 'labels', private pendingMessages: Map<number, { resolve: (value: any) => void; reject: (error: any) => void }> = new Map();
options: { keyPath: 'emoji' },
indices: [],
},
AnkWallet: {
name: 'wallet',
options: { keyPath: 'pre_id' },
indices: [],
},
AnkProcess: {
name: 'processes',
options: {},
indices: [],
},
AnkSharedSecrets: {
name: 'shared_secrets',
options: {},
indices: [],
},
AnkUnconfirmedSecrets: {
name: 'unconfirmed_secrets',
options: { autoIncrement: true },
indices: [],
},
AnkPendingDiffs: {
name: 'diffs',
options: { keyPath: 'value_commitment' },
indices: [
{ name: 'byStateId', keyPath: 'state_id', options: { unique: false } },
{ name: 'byNeedValidation', keyPath: 'need_validation', options: { unique: false } },
{ name: 'byStatus', keyPath: 'validation_status', options: { unique: false } },
],
},
AnkData: {
name: 'data',
options: {},
indices: [],
},
};
// Private constructor to prevent direct instantiation from outside // ============================================
private constructor() {} // INITIALIZATION & SINGLETON
// ============================================
private constructor() {
this.initIndexedDBWorker();
this.initServiceWorker();
}
// Method to access the singleton instance of Database
public static async getInstance(): Promise<Database> { public static async getInstance(): Promise<Database> {
if (!Database.instance) { if (!Database.instance) {
Database.instance = new Database(); Database.instance = new Database();
await Database.instance.init(); await Database.instance.waitForWorkerReady();
} }
return Database.instance; return Database.instance;
} }
// Initialize the database // ============================================
private async init(): Promise<void> { // INDEXEDDB WEB WORKER
// ============================================
private initIndexedDBWorker(): void {
this.indexedDBWorker = new Worker(new URL('../workers/database.worker.ts', import.meta.url), { type: 'module' });
this.indexedDBWorker.onmessage = (event) => {
const { id, type, result, error } = event.data;
const pending = this.pendingMessages.get(id);
if (pending) {
this.pendingMessages.delete(id);
if (type === 'SUCCESS') {
pending.resolve(result);
} else if (type === 'ERROR') {
pending.reject(new Error(error));
}
}
};
this.indexedDBWorker.onerror = (error) => {
console.error('[Database] IndexedDB Worker error:', error);
};
}
private async waitForWorkerReady(): Promise<void> {
return this.sendMessageToWorker('INIT', {});
}
private sendMessageToWorker<T = any>(type: string, payload: any): Promise<T> {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
const request = indexedDB.open(this.dbName, this.dbVersion); if (!this.indexedDBWorker) {
reject(new Error('IndexedDB Worker not initialized'));
return;
}
request.onupgradeneeded = () => { const id = this.messageIdCounter++;
const db = request.result; this.pendingMessages.set(id, { resolve, reject });
Object.values(this.storeDefinitions).forEach(({ name, options, indices }) => { this.indexedDBWorker.postMessage({ type, payload, id });
if (!db.objectStoreNames.contains(name)) {
let store = db.createObjectStore(name, options as IDBObjectStoreParameters);
indices.forEach(({ name, keyPath, options }) => { // Timeout de sécurité (30 secondes)
store.createIndex(name, keyPath, options); setTimeout(() => {
}); if (this.pendingMessages.has(id)) {
} this.pendingMessages.delete(id);
}); reject(new Error(`Worker message timeout for type: ${type}`));
}; }
}, 30000);
request.onsuccess = async () => {
this.db = request.result;
resolve();
};
request.onerror = () => {
console.error('Database error:', request.error);
reject(request.error);
};
}); });
} }
public async getDb(): Promise<IDBDatabase> { // ============================================
if (!this.db) { // SERVICE WORKER
await this.init(); // ============================================
}
return this.db!; private initServiceWorker(): void {
this.registerServiceWorker('/data.worker.js');
} }
public getStoreList(): { [key: string]: string } { private async registerServiceWorker(path: string): Promise<void> {
const objectList: { [key: string]: string } = {};
Object.keys(this.storeDefinitions).forEach((key) => {
objectList[key] = this.storeDefinitions[key as keyof typeof this.storeDefinitions].name;
});
return objectList;
}
public async registerServiceWorker(path: string) {
if (!('serviceWorker' in navigator)) return; if (!('serviceWorker' in navigator)) return;
console.log('[Database] Initialisation du Service Worker sur :', path); console.log('[Database] Initializing Service Worker:', path);
try { try {
// 1. NETTOYAGE DES ANCIENS WORKERS (ZOMBIES)
const registrations = await navigator.serviceWorker.getRegistrations(); const registrations = await navigator.serviceWorker.getRegistrations();
for (const registration of registrations) { for (const registration of registrations) {
const scriptURL = registration.active?.scriptURL || registration.installing?.scriptURL || registration.waiting?.scriptURL; const scriptURL = registration.active?.scriptURL || registration.installing?.scriptURL || registration.waiting?.scriptURL;
const scope = registration.scope; const scope = registration.scope;
// On détecte spécifiquement l'ancien dossier qui pose problème
// L'erreur mentionne : scope ('.../src/service-workers/')
if (scope.includes('/src/service-workers/') || (scriptURL && scriptURL.includes('/src/service-workers/'))) { if (scope.includes('/src/service-workers/') || (scriptURL && scriptURL.includes('/src/service-workers/'))) {
console.warn(`[Database] 🚨 ANCIEN Service Worker détecté (${scope}). Suppression immédiate...`); console.warn(`[Database] Removing old Service Worker (${scope})`);
await registration.unregister(); await registration.unregister();
// On continue la boucle, ne pas retourner ici, il faut installer le nouveau après
} }
} }
// 2. INSTALLATION DU NOUVEAU WORKER (PROPRE)
// On vérifie s'il est déjà installé à la BONNE adresse
const existingValidWorker = registrations.find((r) => { const existingValidWorker = registrations.find((r) => {
const url = r.active?.scriptURL || r.installing?.scriptURL || r.waiting?.scriptURL; const url = r.active?.scriptURL || r.installing?.scriptURL || r.waiting?.scriptURL;
// On compare la fin de l'URL pour éviter les soucis http/https/localhost return url && url.endsWith(path.replace(/^\//,''));
return url && url.endsWith(path.replace(/^\//, ''));
}); });
if (!existingValidWorker) { if (!existingValidWorker) {
console.log('[Database] Enregistrement du nouveau Service Worker...'); console.log('[Database] Registering new Service Worker');
this.serviceWorkerRegistration = await navigator.serviceWorker.register(path, { type: 'module', scope: '/' }); this.serviceWorkerRegistration = await navigator.serviceWorker.register(path, { type: 'module', scope: '/' });
} else { } else {
console.log('[Database] Service Worker déjà actif et valide.'); console.log('[Database] Service Worker already active');
this.serviceWorkerRegistration = existingValidWorker; this.serviceWorkerRegistration = existingValidWorker;
await this.serviceWorkerRegistration.update(); await this.serviceWorkerRegistration.update();
} }
// Set up listeners
navigator.serviceWorker.addEventListener('message', async (event) => { navigator.serviceWorker.addEventListener('message', async (event) => {
// console.log('Received message from service worker:', event.data); if (event.data.type === 'DB_REQUEST') {
await this.handleDatabaseRequest(event.data);
return;
}
await this.handleServiceWorkerMessage(event.data); await this.handleServiceWorkerMessage(event.data);
}); });
// Periodic check
if (this.serviceWorkerCheckIntervalId) clearInterval(this.serviceWorkerCheckIntervalId); if (this.serviceWorkerCheckIntervalId) clearInterval(this.serviceWorkerCheckIntervalId);
this.serviceWorkerCheckIntervalId = window.setInterval(async () => { this.serviceWorkerCheckIntervalId = window.setInterval(async () => {
const activeWorker = this.serviceWorkerRegistration?.active || (await this.waitForServiceWorkerActivation(this.serviceWorkerRegistration!)); const activeWorker = this.serviceWorkerRegistration?.active || (await this.waitForServiceWorkerActivation(this.serviceWorkerRegistration!));
@ -162,13 +140,12 @@ export class Database {
if (payload && payload.length != 0) { if (payload && payload.length != 0) {
activeWorker?.postMessage({ type: 'SCAN', payload }); activeWorker?.postMessage({ type: 'SCAN', payload });
} }
}, APP_CONFIG.TIMEOUTS.WORKER_CHECK); }, 5000);
} catch (error) { } catch (error) {
console.error('[Database] 💥 Erreur critique Service Worker:', error); console.error('[Database] Service Worker error:', error);
} }
} }
// Helper function to wait for service worker activation
private async waitForServiceWorkerActivation(registration: ServiceWorkerRegistration): Promise<ServiceWorker | null> { private async waitForServiceWorkerActivation(registration: ServiceWorkerRegistration): Promise<ServiceWorker | null> {
return new Promise((resolve) => { return new Promise((resolve) => {
if (registration.active) { if (registration.active) {
@ -185,13 +162,11 @@ export class Database {
}); });
} }
private async checkForUpdates() { private async checkForUpdates(): Promise<void> {
if (this.serviceWorkerRegistration) { if (this.serviceWorkerRegistration) {
// Check for updates to the service worker
try { try {
await this.serviceWorkerRegistration.update(); await this.serviceWorkerRegistration.update();
// If there's a new worker waiting, activate it immediately
if (this.serviceWorkerRegistration.waiting) { if (this.serviceWorkerRegistration.waiting) {
this.serviceWorkerRegistration.waiting.postMessage({ type: 'SKIP_WAITING' }); this.serviceWorkerRegistration.waiting.postMessage({ type: 'SKIP_WAITING' });
} }
@ -201,24 +176,85 @@ export class Database {
} }
} }
// ============================================
// SERVICE WORKER MESSAGE HANDLERS
// ============================================
private async handleDatabaseRequest(request: any): Promise<void> {
const { id, action, payload } = request;
try {
let result;
switch (action) {
case 'GET_OBJECT':
result = await this.getObject(payload.storeName, payload.key);
break;
case 'GET_MULTIPLE_OBJECTS':
result = await this.sendMessageToWorker('GET_MULTIPLE_OBJECTS', payload);
break;
case 'GET_ALL_OBJECTS':
result = await this.sendMessageToWorker('GET_ALL_OBJECTS', payload);
break;
case 'GET_ALL_OBJECTS_WITH_FILTER':
result = await this.sendMessageToWorker('GET_ALL_OBJECTS_WITH_FILTER', payload);
break;
default:
throw new Error(`Unknown database action: ${action}`);
}
if (this.serviceWorkerRegistration?.active) {
this.serviceWorkerRegistration.active.postMessage({
type: 'DB_RESPONSE',
id,
result
});
}
} catch (error: any) {
console.error('[Database] Error handling database request:', error);
if (this.serviceWorkerRegistration?.active) {
this.serviceWorkerRegistration.active.postMessage({
type: 'DB_ERROR',
id,
error: error.message || String(error)
});
}
}
}
private async handleServiceWorkerMessage(message: any) { private async handleServiceWorkerMessage(message: any) {
switch (message.type) { switch (message.type) {
case 'TO_DOWNLOAD': case 'TO_DOWNLOAD':
await this.handleDownloadList(message.data); await this.handleDownloadList(message.data);
break; break;
case 'DIFFS_TO_CREATE':
await this.handleDiffsToCreate(message.data);
break;
default: default:
console.warn('Unknown message type received from service worker:', message); console.warn('Unknown message type received from service worker:', message);
} }
} }
private async handleDiffsToCreate(diffs: any[]): Promise<void> {
console.log(`[Database] Creating ${diffs.length} diffs from Service Worker scan`);
try {
await this.saveDiffs(diffs);
console.log('[Database] Diffs created successfully');
} catch (error) {
console.error('[Database] Error creating diffs:', error);
}
}
private async handleDownloadList(downloadList: string[]): Promise<void> { private async handleDownloadList(downloadList: string[]): Promise<void> {
// Download the missing data
let requestedStateId: string[] = []; let requestedStateId: string[] = [];
const service = await Services.getInstance(); const service = await Services.getInstance();
for (const hash of downloadList) { for (const hash of downloadList) {
const diff = await service.getDiffByValue(hash); const diff = await service.getDiffByValue(hash);
if (!diff) { if (!diff) {
// This should never happen
console.warn(`Missing a diff for hash ${hash}`); console.warn(`Missing a diff for hash ${hash}`);
continue; continue;
} }
@ -228,22 +264,15 @@ export class Database {
try { try {
const valueBytes = await service.fetchValueFromStorage(hash); const valueBytes = await service.fetchValueFromStorage(hash);
if (valueBytes) { if (valueBytes) {
// Save data to db
const blob = new Blob([valueBytes], { type: 'application/octet-stream' }); const blob = new Blob([valueBytes], { type: 'application/octet-stream' });
await service.saveBlobToDb(hash, blob); await service.saveBlobToDb(hash, blob);
document.dispatchEvent( document.dispatchEvent(
new CustomEvent('newDataReceived', { new CustomEvent('newDataReceived', {
detail: { detail: { processId, stateId, hash },
processId,
stateId,
hash,
},
}), }),
); );
} else { } else {
// We first request the data from managers
console.log('Request data from managers of the process'); console.log('Request data from managers of the process');
// get the diff from db
if (!requestedStateId.includes(stateId)) { if (!requestedStateId.includes(stateId)) {
await service.requestDataFromPeers(processId, [stateId], [roles]); await service.requestDataFromPeers(processId, [stateId], [roles]);
requestedStateId.push(stateId); requestedStateId.push(stateId);
@ -255,214 +284,182 @@ export class Database {
} }
} }
private handleAddObjectResponse = async (event: MessageEvent) => { // ============================================
const data = event.data; // GENERIC INDEXEDDB OPERATIONS
console.log('Received response from service worker (ADD_OBJECT):', data); // ============================================
const service = await Services.getInstance();
if (data.type === 'NOTIFICATIONS') {
service.setNotifications(data.data);
} else if (data.type === 'TO_DOWNLOAD') {
console.log(`Received missing data ${data}`);
// Download the missing data
let requestedStateId: string[] = [];
for (const hash of data.data) {
try {
const valueBytes = await service.fetchValueFromStorage(hash);
if (valueBytes) {
// Save data to db
const blob = new Blob([valueBytes], { type: 'application/octet-stream' });
await service.saveBlobToDb(hash, blob);
} else {
// We first request the data from managers
console.log('Request data from managers of the process');
// get the diff from db
const diff = await service.getDiffByValue(hash);
if (diff === null) {
continue;
}
const processId = diff!.process_id;
const stateId = diff!.state_id;
const roles = diff!.roles;
if (!requestedStateId.includes(stateId)) {
await service.requestDataFromPeers(processId, [stateId], [roles]);
requestedStateId.push(stateId);
}
}
} catch (e) {
console.error(e);
}
}
}
};
private handleGetObjectResponse = (event: MessageEvent) => { public async getStoreList(): Promise<{ [key: string]: string }> {
console.log('Received response from service worker (GET_OBJECT):', event.data); return this.sendMessageToWorker('GET_STORE_LIST', {});
};
public addObject(payload: { storeName: string; object: any; key: any }): Promise<void> {
return new Promise(async (resolve, reject) => {
// Check if the service worker is active
if (!this.serviceWorkerRegistration) {
// console.warn('Service worker registration is not ready. Waiting...');
this.serviceWorkerRegistration = await navigator.serviceWorker.ready;
}
const activeWorker = await this.waitForServiceWorkerActivation(this.serviceWorkerRegistration);
// Create a message channel for communication
const messageChannel = new MessageChannel();
// Handle the response from the service worker
messageChannel.port1.onmessage = (event) => {
if (event.data.status === 'success') {
resolve();
} else {
const error = event.data.message;
reject(new Error(error || 'Unknown error occurred while adding object'));
}
};
// Send the add object request to the service worker
try {
activeWorker?.postMessage(
{
type: 'ADD_OBJECT',
payload,
},
[messageChannel.port2],
);
} catch (error) {
reject(new Error(`Failed to send message to service worker: ${error}`));
}
});
} }
public batchWriting(payload: { storeName: string; objects: { key: any; object: any }[] }): Promise<void> { public async addObject(payload: { storeName: string; object: any; key: any }): Promise<void> {
return new Promise(async (resolve, reject) => { await this.sendMessageToWorker('ADD_OBJECT', payload);
if (!this.serviceWorkerRegistration) { }
this.serviceWorkerRegistration = await navigator.serviceWorker.ready;
}
const activeWorker = await this.waitForServiceWorkerActivation(this.serviceWorkerRegistration); public async batchWriting(payload: { storeName: string; objects: { key: any; object: any }[] }): Promise<void> {
const messageChannel = new MessageChannel(); await this.sendMessageToWorker('BATCH_WRITING', payload);
messageChannel.port1.onmessage = (event) => {
if (event.data.status === 'success') {
resolve();
} else {
const error = event.data.message;
reject(new Error(error || 'Unknown error occurred while adding objects'));
}
};
try {
activeWorker?.postMessage(
{
type: 'BATCH_WRITING',
payload,
},
[messageChannel.port2],
);
} catch (error) {
reject(new Error(`Failed to send message to service worker: ${error}`));
}
});
} }
public async getObject(storeName: string, key: string): Promise<any | null> { public async getObject(storeName: string, key: string): Promise<any | null> {
const db = await this.getDb(); return this.sendMessageToWorker('GET_OBJECT', { storeName, key });
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);
});
return result ?? null; // Convert undefined to null
} }
public async dumpStore(storeName: string): Promise<Record<string, any>> { public async dumpStore(storeName: string): Promise<Record<string, any>> {
const db = await this.getDb(); return this.sendMessageToWorker('DUMP_STORE', { storeName });
const tx = db.transaction(storeName, 'readonly');
const store = tx.objectStore(storeName);
try {
return new Promise((resolve, reject) => {
const result: Record<string, any> = {};
const cursor = store.openCursor();
cursor.onsuccess = (event) => {
const request = event.target as IDBRequest<IDBCursorWithValue | null>;
const cursor = request.result;
if (cursor) {
result[cursor.key as string] = cursor.value;
cursor.continue();
} else {
resolve(result);
}
};
cursor.onerror = () => {
reject(cursor.error);
};
});
} catch (error) {
console.error('Error fetching data from IndexedDB:', error);
throw error;
}
} }
public async deleteObject(storeName: string, key: string): Promise<void> { public async deleteObject(storeName: string, key: string): Promise<void> {
const db = await this.getDb(); await this.sendMessageToWorker('DELETE_OBJECT', { storeName, key });
const tx = db.transaction(storeName, 'readwrite');
const store = tx.objectStore(storeName);
try {
await new Promise((resolve, reject) => {
const getRequest = store.delete(key);
getRequest.onsuccess = () => resolve(getRequest.result);
getRequest.onerror = () => reject(getRequest.error);
});
} catch (e) {
throw e;
}
} }
public async clearStore(storeName: string): Promise<void> { public async clearStore(storeName: string): Promise<void> {
const db = await this.getDb(); await this.sendMessageToWorker('CLEAR_STORE', { storeName });
const tx = db.transaction(storeName, 'readwrite'); }
const store = tx.objectStore(storeName);
try { public async requestStoreByIndex(storeName: string, indexName: string, request: string): Promise<any[]> {
await new Promise((resolve, reject) => { return this.sendMessageToWorker('REQUEST_STORE_BY_INDEX', { storeName, indexName, request });
const clearRequest = store.clear(); }
clearRequest.onsuccess = () => resolve(clearRequest.result);
clearRequest.onerror = () => reject(clearRequest.error); public async clearMultipleStores(storeNames: string[]): Promise<void> {
}); for (const storeName of storeNames) {
} catch (e) { await this.clearStore(storeName);
throw e;
} }
} }
// Request a store by index // ============================================
public async requestStoreByIndex(storeName: string, indexName: string, request: string): Promise<any[]> { // BUSINESS METHODS - DEVICE
const db = await this.getDb(); // ============================================
const tx = db.transaction(storeName, 'readonly');
const store = tx.objectStore(storeName);
const index = store.index(indexName);
public async saveDevice(device: any): Promise<void> {
try { try {
return new Promise((resolve, reject) => { const existing = await this.getObject('wallet', '1');
const getAllRequest = index.getAll(request); if (existing) {
getAllRequest.onsuccess = () => { await this.deleteObject('wallet', '1');
const allItems = getAllRequest.result; }
const filtered = allItems.filter((item) => item.state_id === request); } catch (e) {}
resolve(filtered);
}; await this.addObject({
getAllRequest.onerror = () => reject(getAllRequest.error); storeName: 'wallet',
object: { pre_id: '1', device },
key: null,
});
}
public async getDevice(): Promise<any | null> {
const result = await this.getObject('wallet', '1');
console.log(result);
return result ? result['device'] : null;
}
// ============================================
// BUSINESS METHODS - PROCESS
// ============================================
public async saveProcess(processId: string, process: any): Promise<void> {
await this.addObject({
storeName: 'processes',
object: process,
key: processId,
});
}
public async saveProcessesBatch(processes: Record<string, any>): Promise<void> {
if (Object.keys(processes).length === 0) return;
await this.batchWriting({
storeName: 'processes',
objects: Object.entries(processes).map(([key, value]) => ({ key, object: value })),
});
}
public async getProcess(processId: string): Promise<any | null> {
return this.getObject('processes', processId);
}
public async getAllProcesses(): Promise<Record<string, any>> {
return this.dumpStore('processes');
}
// ============================================
// BUSINESS METHODS - BLOBS
// ============================================
public async saveBlob(hash: string, data: Blob): Promise<void> {
await this.addObject({
storeName: 'data',
object: data,
key: hash,
});
}
public async getBlob(hash: string): Promise<Blob | null> {
return this.getObject('data', hash);
}
// ============================================
// BUSINESS METHODS - DIFFS
// ============================================
public async saveDiffs(diffs: any[]): Promise<void> {
if (diffs.length === 0) return;
for (const diff of diffs) {
await this.addObject({
storeName: 'diffs',
object: diff,
key: null,
}); });
} catch (e) {
throw e;
} }
} }
public async getDiff(hash: string): Promise<any | null> {
return this.getObject('diffs', hash);
}
public async getAllDiffs(): Promise<Record<string, any>> {
return this.dumpStore('diffs');
}
// ============================================
// BUSINESS METHODS - SECRETS
// ============================================
public async getSharedSecret(address: string): Promise<string | null> {
return this.getObject('shared_secrets', address);
}
public async saveSecretsBatch(unconfirmedSecrets: any[], sharedSecrets: { key: string; value: any }[]): Promise<void> {
if (unconfirmedSecrets && unconfirmedSecrets.length > 0) {
for (const secret of unconfirmedSecrets) {
await this.addObject({
storeName: 'unconfirmed_secrets',
object: secret,
key: null,
});
}
}
if (sharedSecrets && sharedSecrets.length > 0) {
for (const { key, value } of sharedSecrets) {
await this.addObject({
storeName: 'shared_secrets',
object: value,
key: key,
});
}
}
}
public async getAllSecrets(): Promise<{ shared_secrets: Record<string, any>; unconfirmed_secrets: any[] }> {
const sharedSecrets = await this.dumpStore('shared_secrets');
const unconfirmedSecrets = await this.dumpStore('unconfirmed_secrets');
return {
shared_secrets: sharedSecrets,
unconfirmed_secrets: Object.values(unconfirmedSecrets),
};
}
} }
export default Database; export default Database;

15
src/services/domain/process.service.ts
View File

@ -8,13 +8,12 @@ export class ProcessService {
private processesCache: Record<string, Process> = {}; private processesCache: Record<string, Process> = {};
private myProcesses: Set<string> = new Set(); private myProcesses: Set<string> = new Set();
constructor(private sdk: SdkService) {} constructor(private sdk: SdkService, private db: Database) {}
public async getProcess(processId: string): Promise<Process | null> { public async getProcess(processId: string): Promise<Process | null> {
if (this.processesCache[processId]) return this.processesCache[processId]; if (this.processesCache[processId]) return this.processesCache[processId];
const db = await Database.getInstance(); const process = await this.db.getProcess(processId);
const process = await db.getObject('processes', processId);
if (process) this.processesCache[processId] = process; if (process) this.processesCache[processId] = process;
return process; return process;
} }
@ -22,21 +21,18 @@ export class ProcessService {
public async getProcesses(): Promise<Record<string, Process>> { public async getProcesses(): Promise<Record<string, Process>> {
if (Object.keys(this.processesCache).length > 0) return this.processesCache; if (Object.keys(this.processesCache).length > 0) return this.processesCache;
const db = await Database.getInstance(); this.processesCache = await this.db.getAllProcesses();
this.processesCache = await db.dumpStore('processes');
return this.processesCache; return this.processesCache;
} }
public async saveProcessToDb(processId: string, process: Process) { public async saveProcessToDb(processId: string, process: Process) {
const db = await Database.getInstance(); await this.db.saveProcess(processId, process);
await db.addObject({ storeName: 'processes', object: process, key: processId });
this.processesCache[processId] = process; this.processesCache[processId] = process;
} }
public async batchSaveProcesses(processes: Record<string, Process>) { public async batchSaveProcesses(processes: Record<string, Process>) {
if (Object.keys(processes).length === 0) return; if (Object.keys(processes).length === 0) return;
const db = await Database.getInstance(); await this.db.saveProcessesBatch(processes);
await db.batchWriting({ storeName: 'processes', objects: Object.entries(processes).map(([key, value]) => ({ key, object: value })) });
this.processesCache = { ...this.processesCache, ...processes }; this.processesCache = { ...this.processesCache, ...processes };
} }
@ -86,7 +82,6 @@ export class ProcessService {
return Array.from(this.myProcesses); return Array.from(this.myProcesses);
} }
// --- AJOUT : Méthode manquante ---
public getLastCommitedStateIndex(process: Process): number | null { public getLastCommitedStateIndex(process: Process): number | null {
if (process.states.length === 0) return null; if (process.states.length === 0) return null;
const processTip = process.states[process.states.length - 1].commited_in; const processTip = process.states[process.states.length - 1].commited_in;

11
src/services/domain/wallet.service.ts
View File

@ -3,7 +3,7 @@ import { SdkService } from '../core/sdk.service';
import Database from '../database.service'; import Database from '../database.service';
export class WalletService { export class WalletService {
constructor(private sdk: SdkService) {} constructor(private sdk: SdkService, private db: Database) {}
public isPaired(): boolean { public isPaired(): boolean {
try { try {
@ -49,7 +49,6 @@ export class WalletService {
} }
} }
// --- AJOUTS (Manquants) ---
public async dumpWallet(): Promise<any> { public async dumpWallet(): Promise<any> {
return await this.sdk.getClient().dump_wallet(); return await this.sdk.getClient().dump_wallet();
} }
@ -70,13 +69,7 @@ export class WalletService {
// ------------------------- // -------------------------
public async saveDeviceInDatabase(device: Device): Promise<void> { public async saveDeviceInDatabase(device: Device): Promise<void> {
const db = await Database.getInstance(); await this.db.saveDevice(device);
await db.deleteObject('wallet', '1').catch(() => {});
await db.addObject({
storeName: 'wallet',
object: { pre_id: '1', device },
key: null,
});
} }
public async getDeviceFromDatabase(): Promise<Device | null> { public async getDeviceFromDatabase(): Promise<Device | null> {

2
src/services/iframe-controller.service.ts
View File

@ -139,7 +139,7 @@ export class IframeController {
await services.handleApiReturn(approveChangeReturn); await services.handleApiReturn(approveChangeReturn);
console.log('[Router:API] 7/7: Confirmation finale du pairing...'); console.log('[Router:API] 7/7: Confirmation finale du pairing...');
await services.confirmPairing(); // await services.confirmPairing();
console.log('[Router:API] 🎉 Appairage terminé avec succès !'); console.log('[Router:API] 🎉 Appairage terminé avec succès !');

158
src/services/service.ts
View File

@ -17,14 +17,15 @@ export default class Services {
private sdkService: SdkService; private sdkService: SdkService;
public networkService: NetworkService; public networkService: NetworkService;
private walletService: WalletService; private walletService!: WalletService;
private processService: ProcessService; private processService!: ProcessService;
private cryptoService: CryptoService; private cryptoService: CryptoService;
private processId: string | null = null; private processId: string | null = null;
private stateId: string | null = null; private stateId: string | null = null;
private membersList: Record<string, Member> = {}; private membersList: Record<string, Member> = {};
private notifications: any[] | null = null; private notifications: any[] | null = null;
private db!: Database;
private currentBlockHeight: number = -1; private currentBlockHeight: number = -1;
private pendingKeyRequests: Map<string, (key: string) => void> = new Map(); private pendingKeyRequests: Map<string, (key: string) => void> = new Map();
@ -36,8 +37,6 @@ export default class Services {
// Utilisation de la config // Utilisation de la config
this.networkService = new NetworkService(APP_CONFIG.URLS.BOOTSTRAP); this.networkService = new NetworkService(APP_CONFIG.URLS.BOOTSTRAP);
this.cryptoService = new CryptoService(this.sdkService); this.cryptoService = new CryptoService(this.sdkService);
this.walletService = new WalletService(this.sdkService);
this.processService = new ProcessService(this.sdkService);
} }
public static async getInstance(): Promise<Services> { public static async getInstance(): Promise<Services> {
@ -57,6 +56,10 @@ export default class Services {
console.log('[Services] ⏳ Initialisation...'); console.log('[Services] ⏳ Initialisation...');
this.notifications = this.getNotifications(); this.notifications = this.getNotifications();
await this.sdkService.init(); await this.sdkService.init();
this.db = await Database.getInstance();
this.walletService = new WalletService(this.sdkService, this.db);
this.processService = new ProcessService(this.sdkService, this.db);
this.networkService.initRelays(); this.networkService.initRelays();
console.log('[Services] ✅ Initialisé.'); console.log('[Services] ✅ Initialisé.');
} }
@ -251,13 +254,32 @@ export default class Services {
public async handleHandshakeMsg(url: string, parsedMsg: any) { public async handleHandshakeMsg(url: string, parsedMsg: any) {
try { try {
const handshakeMsg: HandshakeMessage = JSON.parse(parsedMsg); const handshakeMsg: HandshakeMessage = JSON.parse(parsedMsg);
if (handshakeMsg.sp_address) this.updateRelay(url, handshakeMsg.sp_address);
if (handshakeMsg.sp_address) {
this.updateRelay(url, handshakeMsg.sp_address);
}
this.currentBlockHeight = handshakeMsg.chain_tip; this.currentBlockHeight = handshakeMsg.chain_tip;
if (!this.isPaired()) {
console.log(`[Services] ⏳ Non pairé. Le Handshake de ${url} est en pause...`);
while (!this.isPaired()) {
await new Promise(r => setTimeout(r, 500));
}
console.log(`[Services] ▶️ Appareil pairé ! Reprise du traitement Handshake de ${url}.`);
}
this.updateDeviceBlockHeight(); this.updateDeviceBlockHeight();
if (handshakeMsg.peers_list) this.membersList = { ...this.membersList, ...(handshakeMsg.peers_list as Record<string, Member>) };
if (handshakeMsg.processes_list) this.syncProcessesFromHandshake(handshakeMsg.processes_list); if (handshakeMsg.peers_list) {
} catch (e) { this.membersList = { ...this.membersList, ...handshakeMsg.peers_list as Record<string, Member> };
console.error('Handshake Error', e); }
if (handshakeMsg.processes_list) {
this.syncProcessesFromHandshake(handshakeMsg.processes_list);
}
} catch(e) {
console.error("Handshake Error", e);
} }
} }
@ -549,32 +571,32 @@ export default class Services {
return res; return res;
} }
public async confirmPairing() { // public async confirmPairing() {
console.log('[Services] Confirm Pairing...'); // console.log('[Services] Confirm Pairing...');
const pid = this.walletService.getPairingProcessId(); // const pid = this.walletService.getPairingProcessId();
const process = await this.processService.getProcess(pid); // const process = await this.processService.getProcess(pid);
if (!process) return; // if (!process) return;
let state = this.processService.getLastCommitedState(process); // let state = this.processService.getLastCommitedState(process);
if (!state && process.states.length > 0) state = process.states[process.states.length - 1]; // if (!state && process.states.length > 0) state = process.states[process.states.length - 1];
if (!state) return; // if (!state) return;
const encodedAddr = state.public_data['pairedAddresses']; // const encodedAddr = state.public_data['pairedAddresses'];
if (!encodedAddr) return; // if (!encodedAddr) return;
const addresses = this.decodeValue(encodedAddr); // const addresses = this.decodeValue(encodedAddr);
if (!addresses || addresses.length === 0) return; // if (!addresses || addresses.length === 0) return;
this.sdkClient.unpair_device(); // this.sdkClient.unpair_device();
this.walletService.pairDevice(pid, addresses); // this.walletService.pairDevice(pid, addresses);
if (this.walletService.isPaired()) { // if (this.walletService.isPaired()) {
const d = this.walletService.dumpDeviceFromMemory(); // const d = this.walletService.dumpDeviceFromMemory();
if (!this.walletService.isPaired()) d.pairing_process_commitment = pid; // if (!this.walletService.isPaired()) d.pairing_process_commitment = pid;
await this.walletService.saveDeviceInDatabase(d); // await this.walletService.saveDeviceInDatabase(d);
console.log('✅ Pairing confirmed & Saved'); // console.log('✅ Pairing confirmed & Saved');
} // }
} // }
private async prepareProcessData(priv: any, pub: any) { private async prepareProcessData(priv: any, pub: any) {
const p1 = this.splitData(priv); const p1 = this.splitData(priv);
@ -609,15 +631,14 @@ export default class Services {
const res = this.sdkClient.request_data(pid, sids, roles, this.membersList); const res = this.sdkClient.request_data(pid, sids, roles, this.membersList);
await this.handleApiReturn(res); await this.handleApiReturn(res);
} }
public async resetDevice() { public async resetDevice() {
console.warn('Resetting device...'); // console.warn("[Services:resetDevice] ⚠️ RÉINITIALISATION COMPLÈTE de l'appareil et de la BDD...");
this.sdkClient.reset_device(); this.sdkClient.reset_device();
const db = await Database.getInstance();
await db.clearStore('wallet'); // Clear all stores
await db.clearStore('processes'); await this.db.clearMultipleStores(['wallet', 'shared_secrets', 'unconfirmed_secrets', 'processes', 'diffs']);
await db.clearStore('shared_secrets'); // console.warn('[Services:resetDevice] ✅ Réinitialisation terminée.');
await db.clearStore('unconfirmed_secrets');
await db.clearStore('diffs');
} }
public async handleApiReturn(res: ApiReturn) { public async handleApiReturn(res: ApiReturn) {
@ -647,9 +668,20 @@ export default class Services {
} }
private async handleSecrets(secrets: any) { private async handleSecrets(secrets: any) {
const db = await Database.getInstance(); const { unconfirmed_secrets, shared_secrets } = secrets;
if (secrets.unconfirmed_secrets) for (const s of secrets.unconfirmed_secrets) await db.addObject({ storeName: 'unconfirmed_secrets', object: s, key: null });
if (secrets.shared_secrets) for (const [k, v] of Object.entries(secrets.shared_secrets)) await db.addObject({ storeName: 'shared_secrets', object: v, key: k }); const unconfirmedList = unconfirmed_secrets && unconfirmed_secrets.length > 0 ? unconfirmed_secrets : [];
const sharedList = shared_secrets && Object.keys(shared_secrets).length > 0
? Object.entries(shared_secrets).map(([key, value]) => ({ key, value }))
: [];
if (unconfirmedList.length > 0 || sharedList.length > 0) {
try {
await this.db.saveSecretsBatch(unconfirmedList, sharedList);
} catch (e) {
console.error('[Services:handleSecrets] 💥 Échec de sauvegarde batch des secrets:', e);
}
}
} }
private async handleUpdatedProcess(updated: any) { private async handleUpdatedProcess(updated: any) {
@ -669,8 +701,7 @@ export default class Services {
} }
public async saveDiffsToDb(diffs: UserDiff[]) { public async saveDiffsToDb(diffs: UserDiff[]) {
const db = await Database.getInstance(); await this.db.saveDiffs(diffs);
for (const d of diffs) await db.addObject({ storeName: 'diffs', object: d, key: null });
} }
private _resolvePendingKeyRequests(processId: string, process: Process) { private _resolvePendingKeyRequests(processId: string, process: Process) {
@ -711,37 +742,28 @@ export default class Services {
return this.processService.rolesContainsMember(roles, this.getPairingProcessId()); return this.processService.rolesContainsMember(roles, this.getPairingProcessId());
} }
public async getSecretForAddress(addr: string) { public async getSecretForAddress(address: string): Promise<string | null> {
const db = await Database.getInstance(); return await this.db.getSharedSecret(address);
return await db.getObject('shared_secrets', addr);
} }
public async getAllDiffs(): Promise<Record<string, UserDiff>> { public async getAllDiffs(): Promise<Record<string, UserDiff>> {
const db = await Database.getInstance(); return await this.db.getAllDiffs();
return await db.dumpStore('diffs');
} }
public async getDiffByValueFromDb(hash: string): Promise<UserDiff | null> { public async getDiffByValue(value: string): Promise<UserDiff | null> {
const db = await Database.getInstance(); return await this.db.getDiff(value);
return await db.getObject('diffs', hash);
} }
public async getAllSecrets() { public async getAllSecrets(): Promise<SecretsStore> {
const db = await Database.getInstance(); return await this.db.getAllSecrets();
return {
shared_secrets: await db.dumpStore('shared_secrets'),
unconfirmed_secrets: Object.values(await db.dumpStore('unconfirmed_secrets')),
};
} }
// Storage & DB // Storage & DB
public async saveBlobToDb(h: string, b: Blob) { public async saveBlobToDb(h: string, d: Blob) {
const db = await Database.getInstance(); await this.db.saveBlob(h, d);
await db.addObject({ storeName: 'data', object: b, key: h });
} }
public async getBlobFromDb(h: string) { public async getBlobFromDb(h: string) {
const db = await Database.getInstance(); return await this.db.getBlob(h);
return await db.getObject('data', h);
} }
public async fetchValueFromStorage(h: string) { public async fetchValueFromStorage(h: string) {
return retrieveData([APP_CONFIG.URLS.STORAGE], h); return retrieveData([APP_CONFIG.URLS.STORAGE], h);
@ -749,10 +771,6 @@ export default class Services {
public async saveDataToStorage(s: string[], h: string, d: Blob, ttl: number | null) { public async saveDataToStorage(s: string[], h: string, d: Blob, ttl: number | null) {
return storeData(s, h, d, ttl); return storeData(s, h, d, ttl);
} }
public async getDiffByValue(val: string) {
const db = await Database.getInstance();
return await db.getObject('diffs', val);
}
// Helpers // Helpers
public getProcessName(p: Process) { public getProcessName(p: Process) {
@ -821,16 +839,12 @@ export default class Services {
await this.restoreSecretsFromBackUp(backup.secrets); await this.restoreSecretsFromBackUp(backup.secrets);
} }
public async restoreSecretsFromBackUp(secretsStore: SecretsStore) { public async restoreSecretsFromBackUp(secretsStore: SecretsStore) {
const db = await Database.getInstance(); const sharedList = Object.entries(secretsStore.shared_secrets).map(([key, value]) => ({ key, value }));
for (const secret of secretsStore.unconfirmed_secrets) await db.addObject({ storeName: 'unconfirmed_secrets', object: secret, key: null }); await this.db.saveSecretsBatch(secretsStore.unconfirmed_secrets, sharedList);
for (const [key, value] of Object.entries(secretsStore.shared_secrets)) await db.addObject({ storeName: 'shared_secrets', object: value, key });
await this.restoreSecretsFromDB(); await this.restoreSecretsFromDB();
} }
public async restoreSecretsFromDB() { public async restoreSecretsFromDB() {
const db = await Database.getInstance(); const secretsStore = await this.db.getAllSecrets();
const sharedSecrets: Record<string, string> = await db.dumpStore('shared_secrets');
const unconfirmedSecrets = await db.dumpStore('unconfirmed_secrets');
const secretsStore = { shared_secrets: sharedSecrets, unconfirmed_secrets: Object.values(unconfirmedSecrets) };
this.sdkClient.set_shared_secrets(JSON.stringify(secretsStore)); this.sdkClient.set_shared_secrets(JSON.stringify(secretsStore));
} }
public async createBackUp() { public async createBackUp() {

381
src/workers/database.worker.ts Normal file
View File

@ -0,0 +1,381 @@
/**
* Database Web Worker - Handles all IndexedDB operations in background
*/
import type {
StoreDefinition,
WorkerMessagePayload,
WorkerMessageResponse,
BatchWriteItem
} from './worker.types';
const DB_NAME = '4nk';
const DB_VERSION = 1;
// ============================================
// STORE DEFINITIONS
// ============================================
const STORE_DEFINITIONS: Record<string, StoreDefinition> = {
AnkLabels: {
name: 'labels',
options: { keyPath: 'emoji' },
indices: [],
},
AnkWallet: {
name: 'wallet',
options: { keyPath: 'pre_id' },
indices: [],
},
AnkProcess: {
name: 'processes',
options: {},
indices: [],
},
AnkSharedSecrets: {
name: 'shared_secrets',
options: {},
indices: [],
},
AnkUnconfirmedSecrets: {
name: 'unconfirmed_secrets',
options: { autoIncrement: true },
indices: [],
},
AnkPendingDiffs: {
name: 'diffs',
options: { keyPath: 'value_commitment' },
indices: [
{ name: 'byStateId', keyPath: 'state_id', options: { unique: false } },
{ name: 'byNeedValidation', keyPath: 'need_validation', options: { unique: false } },
{ name: 'byStatus', keyPath: 'validation_status', options: { unique: false } },
],
},
AnkData: {
name: 'data',
options: {},
indices: [],
},
};
let db: IDBDatabase | null = null;
// ============================================
// DATABASE INITIALIZATION
// ============================================
async function openDatabase(): Promise<IDBDatabase> {
if (db) {
return db;
}
return new Promise((resolve, reject) => {
const request = indexedDB.open(DB_NAME, DB_VERSION);
request.onupgradeneeded = (event: IDBVersionChangeEvent) => {
const database = (event.target as IDBOpenDBRequest).result;
Object.values(STORE_DEFINITIONS).forEach(({ name, options, indices }) => {
if (!database.objectStoreNames.contains(name)) {
const store = database.createObjectStore(name, options);
indices.forEach(({ name: indexName, keyPath, options: indexOptions }) => {
store.createIndex(indexName, keyPath, indexOptions);
});
}
});
};
request.onsuccess = () => {
db = request.result;
resolve(db);
};
request.onerror = () => {
reject(request.error);
};
});
}
// ============================================
// WRITE OPERATIONS
// ============================================
async function addObject(storeName: string, object: any, key?: IDBValidKey): Promise<{ success: boolean }> {
const database = await openDatabase();
const tx = database.transaction(storeName, 'readwrite');
const store = tx.objectStore(storeName);
return new Promise((resolve, reject) => {
let request: IDBRequest;
if (key !== null && key !== undefined) {
request = store.put(object, key);
} else {
request = store.put(object);
}
request.onsuccess = () => resolve({ success: true });
request.onerror = () => reject(request.error);
});
}
async function batchWriting(storeName: string, objects: BatchWriteItem[]): Promise<{ success: boolean }> {
const database = await openDatabase();
const tx = database.transaction(storeName, 'readwrite');
const store = tx.objectStore(storeName);
for (const { key, object } of objects) {
if (key !== null && key !== undefined) {
store.put(object, key);
} else {
store.put(object);
}
}
return new Promise((resolve, reject) => {
tx.oncomplete = () => resolve({ success: true });
tx.onerror = () => reject(tx.error);
});
}
// ============================================
// READ OPERATIONS
// ============================================
async function getObject(storeName: string, key: IDBValidKey): Promise<any> {
const database = await openDatabase();
const tx = database.transaction(storeName, 'readonly');
const store = tx.objectStore(storeName);
return new Promise((resolve, reject) => {
const request = store.get(key);
request.onsuccess = () => resolve(request.result ?? null);
request.onerror = () => reject(request.error);
});
}
async function dumpStore(storeName: string): Promise<Record<string, any>> {
const database = await openDatabase();
const tx = database.transaction(storeName, 'readonly');
const store = tx.objectStore(storeName);
return new Promise((resolve, reject) => {
const result: Record<string, any> = {};
const request = store.openCursor();
request.onsuccess = (event) => {
const cursor = (event.target as IDBRequest<IDBCursorWithValue | null>).result;
if (cursor) {
result[cursor.key as string] = cursor.value;
cursor.continue();
} else {
resolve(result);
}
};
request.onerror = () => reject(request.error);
});
}
async function getAllObjects(storeName: string): Promise<any[]> {
const database = await openDatabase();
const tx = database.transaction(storeName, 'readonly');
const store = tx.objectStore(storeName);
return new Promise((resolve, reject) => {
const request = store.getAll();
request.onsuccess = () => resolve(request.result || []);
request.onerror = () => reject(request.error);
});
}
async function getMultipleObjects(storeName: string, keys: IDBValidKey[]): Promise<any[]> {
const database = await openDatabase();
const tx = database.transaction(storeName, 'readonly');
const store = tx.objectStore(storeName);
const requests = keys.map((key) => {
return new Promise<any>((resolve) => {
const request = store.get(key);
request.onsuccess = () => resolve(request.result || null);
request.onerror = () => {
console.error(`Error fetching key ${key}:`, request.error);
resolve(null);
};
});
});
const results = await Promise.all(requests);
return results.filter(result => result !== null);
}
async function getAllObjectsWithFilter(storeName: string, filterFn?: string): Promise<any[]> {
const database = await openDatabase();
const tx = database.transaction(storeName, 'readonly');
const store = tx.objectStore(storeName);
return new Promise((resolve, reject) => {
const request = store.getAll();
request.onsuccess = () => {
const allItems = request.result || [];
if (filterFn) {
const filter = new Function('item', `return ${filterFn}`) as (item: any) => boolean;
resolve(allItems.filter(filter));
} else {
resolve(allItems);
}
};
request.onerror = () => reject(request.error);
});
}
// ============================================
// DELETE OPERATIONS
// ============================================
async function deleteObject(storeName: string, key: IDBValidKey): Promise<{ success: boolean }> {
const database = await openDatabase();
const tx = database.transaction(storeName, 'readwrite');
const store = tx.objectStore(storeName);
return new Promise((resolve, reject) => {
const request = store.delete(key);
request.onsuccess = () => resolve({ success: true });
request.onerror = () => reject(request.error);
});
}
async function clearStore(storeName: string): Promise<{ success: boolean }> {
const database = await openDatabase();
const tx = database.transaction(storeName, 'readwrite');
const store = tx.objectStore(storeName);
return new Promise((resolve, reject) => {
const request = store.clear();
request.onsuccess = () => resolve({ success: true });
request.onerror = () => reject(request.error);
});
}
// ============================================
// INDEX OPERATIONS
// ============================================
async function requestStoreByIndex(storeName: string, indexName: string, requestValue: IDBValidKey): Promise<any[]> {
const database = await openDatabase();
const tx = database.transaction(storeName, 'readonly');
const store = tx.objectStore(storeName);
const index = store.index(indexName);
return new Promise((resolve, reject) => {
const request = index.getAll(requestValue);
request.onsuccess = () => {
const allItems = request.result;
const filtered = allItems.filter((item: any) => item.state_id === requestValue);
resolve(filtered);
};
request.onerror = () => reject(request.error);
});
}
// ============================================
// UTILITY FUNCTIONS
// ============================================
function getStoreList(): Record<string, string> {
const storeList: Record<string, string> = {};
Object.keys(STORE_DEFINITIONS).forEach((key) => {
storeList[key] = STORE_DEFINITIONS[key].name;
});
return storeList;
}
// ============================================
// MESSAGE HANDLER
// ============================================
self.addEventListener('message', async (event: MessageEvent<WorkerMessagePayload>) => {
const { type, payload, id } = event.data;
try {
let result: any;
switch (type) {
case 'INIT':
await openDatabase();
result = { success: true };
break;
case 'ADD_OBJECT':
result = await addObject(payload.storeName, payload.object, payload.key);
break;
case 'BATCH_WRITING':
result = await batchWriting(payload.storeName, payload.objects);
break;
case 'GET_OBJECT':
result = await getObject(payload.storeName, payload.key);
break;
case 'DUMP_STORE':
result = await dumpStore(payload.storeName);
break;
case 'DELETE_OBJECT':
result = await deleteObject(payload.storeName, payload.key);
break;
case 'CLEAR_STORE':
result = await clearStore(payload.storeName);
break;
case 'REQUEST_STORE_BY_INDEX':
result = await requestStoreByIndex(
payload.storeName,
payload.indexName,
payload.request
);
break;
case 'GET_ALL_OBJECTS':
result = await getAllObjects(payload.storeName);
break;
case 'GET_MULTIPLE_OBJECTS':
result = await getMultipleObjects(payload.storeName, payload.keys);
break;
case 'GET_ALL_OBJECTS_WITH_FILTER':
result = await getAllObjectsWithFilter(payload.storeName, payload.filterFn);
break;
case 'GET_STORE_LIST':
result = getStoreList();
break;
default:
throw new Error(`Unknown message type: ${type}`);
}
self.postMessage({
id,
type: 'SUCCESS',
result,
} as WorkerMessageResponse);
} catch (error) {
self.postMessage({
id,
type: 'ERROR',
error: (error as Error).message || String(error),
} as WorkerMessageResponse);
}
});
// ============================================
// INITIALIZATION
// ============================================
openDatabase().catch((error) => {
console.error('[Database Worker] Failed to initialize database:', error);
});

33
src/workers/worker.types.ts Normal file
View File

@ -0,0 +1,33 @@
/**
* Shared types for Web Workers
*/
export interface StoreDefinition {
name: string;
options: IDBObjectStoreParameters;
indices: IndexDefinition[];
}
export interface IndexDefinition {
name: string;
keyPath: string | string[];
options: IDBIndexParameters;
}
export interface WorkerMessagePayload {
type: string;
payload?: any;
id: number;
}
export interface WorkerMessageResponse {
id: number;
type: 'SUCCESS' | 'ERROR';
result?: any;
error?: string;
}
export interface BatchWriteItem {
key?: IDBValidKey;
object: any;
}