Add sp_wallet creation in ts

src/database.ts

@@ -0,0 +1,134 @@
+class Database {
+    private static instance: Database;
+    private db: IDBDatabase | null = null;
+    private dbName: string = '4nk';
+    private dbVersion: number = 1;
+    private storeDefinitions = {
+        SpClient: {
+            name: "sp_client",
+            options: {}
+        },
+        AnkUser: {
+            name: "4nkUser",
+            options: {}
+        },
+        AnkSession: {
+            name: "4nkSession",
+            options: {}
+        },
+        AnkProcess: {
+            name: "4nkProcess",
+            options: {}
+        }
+    }
+
+    // Private constructor to prevent direct instantiation from outside
+    private constructor() {}
+
+    // Method to access the singleton instance of Database
+    public static async getInstance(): Promise<Database> {
+        if (!Database.instance) {
+            Database.instance = new Database();
+            await Database.instance.init();
+        }
+        return Database.instance;
+    }
+
+    // Initialize the database
+    private async init(): Promise<void> {
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open(this.dbName, this.dbVersion);
+
+            request.onupgradeneeded = () => {
+                const db = request.result;
+                
+                Object.values(this.storeDefinitions).forEach(({name, options}) => {
+                    if (!db.objectStoreNames.contains(name)) {
+                        db.createObjectStore(name, options);
+                    }
+                });
+            };
+
+            request.onsuccess = (event) => {
+                this.db = request.result;
+                resolve();
+            };
+
+            request.onerror = (event) => {
+                console.error("Database error:", request.error);
+                reject(request.error);
+            };
+        });
+    }
+
+    public getDb(): IDBDatabase {
+        if (!this.db) {
+            throw new Error("Database not initialized");
+        }
+        return this.db;
+    }
+
+    public getStoreList(): {[key: string]: string} {
+        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 writeObject(db: IDBDatabase, storeName: string, obj: any, key: string | null): Promise<IDBRequest> {
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction(storeName, 'readwrite');
+            const store = transaction.objectStore(storeName);
+            let request: IDBRequest<any>;
+            if (key) {
+                request = store.add(obj, key);
+            } else {
+                request = store.add(obj);
+            }
+
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve(request.result);
+        });
+    }
+
+    public getObject<T>(db: IDBDatabase, storeName: string, key: string | number): Promise<T> {
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction(storeName, 'readonly');
+            const store = transaction.objectStore(storeName);
+            const request = store.get(key);
+
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve(request.result);
+        });
+    }
+
+    public setObject(db: IDBDatabase, storeName: string, obj: any, key: string | null): Promise<IDBRequest> {
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction(storeName, 'readwrite');
+            const store = transaction.objectStore(storeName);
+            let request: IDBRequest<any>;
+            if (key) {
+                request = store.put(obj, key);
+            } else {
+                request = store.put(obj);
+            }
+
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve(request.result);
+        });
+    }
+
+    public getAll<T>(db: IDBDatabase, storeName: string): Promise<T[]> {
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction(storeName, 'readonly');
+            const store = transaction.objectStore(storeName);
+            const request = store.getAll();
+
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve(request.result);
+        });
+    }
+}
+
+export default Database;

src/index.html

@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>4NK Client</title>
+</head>
+<body>
+</body>
+</html>

src/index.ts

@@ -0,0 +1,15 @@
+import Services from './services';
+import IndexedDB from './database'
+
+document.addEventListener('DOMContentLoaded', async () => {
+    try {
+        const services = await Services.getInstance();
+        const indexedDB = await IndexedDB.getInstance();
+
+        const db = indexedDB.getDb();
+        await indexedDB.writeObject(db, indexedDB.getStoreList().SpClient, services.new_sp_client(), "default");
+    } catch (error) {
+        console.error(error);
+    }
+});
+

src/services.ts

@@ -0,0 +1,49 @@
+import IndexedDB from './database'
+
+class Services {
+    private static instance: Services;
+    private sdkClient: any;
+
+    // Private constructor to prevent direct instantiation from outside
+    private constructor() {}
+
+    // Method to access the singleton instance of Services
+    public static async getInstance(): Promise<Services> {
+        if (!Services.instance) {
+            Services.instance = new Services();
+            await Services.instance.init(); 
+        }
+        return Services.instance;
+    }
+
+    // The init method is now part of the instance, and should only be called once
+    private async init(): Promise<void> {
+        this.sdkClient = await import("../dist/pkg/sdk_client");
+        this.sdkClient.setup();
+    }
+
+    public new_sp_client(): string {
+        return this.sdkClient.generate_sp_wallet();
+    }
+
+    public async getSpAddressDefaultClient(): Promise<string | null> {
+        try {
+            const indexedDB = await IndexedDB.getInstance();
+            const db = indexedDB.getDb();
+            const spClient = await indexedDB.getObject<string>(db, indexedDB.getStoreList().SpClient, "default");
+
+            if (spClient) {
+                return this.sdkClient.get_receiving_address(spClient);
+            } else {
+                console.error("SP client not found");
+                return null;
+            }
+        } catch (error) {
+            console.error("Failed to retrieve object or get sp address:", error);
+            return null; 
+        }
+
+    }
+}
+
+export default Services;