@arkade-os/sdk 0.3.13 → 0.4.0-next.1

package/dist/esm/wallet/serviceWorker/wallet.js

@@ -1,50 +1,135 @@
-import { Response } from './response.js';
 import { hex } from "@scure/base";
-import { IndexedDBStorageAdapter } from '../../storage/indexedDB.js';
-import { WalletRepositoryImpl } from '../../repositories/walletRepository.js';
-import { ContractRepositoryImpl } from '../../repositories/contractRepository.js';
-import { DEFAULT_DB_NAME, setupServiceWorker } from './utils.js';
+import { setupServiceWorker } from '../../worker/browser/utils.js';
+import { IndexedDBContractRepository, IndexedDBWalletRepository, } from '../../repositories/index.js';
+import { DEFAULT_MESSAGE_TAG, } from './wallet-message-handler.js';
+import { getRandomId } from '../utils.js';
 const isPrivateKeyIdentity = (identity) => {
     return typeof identity.toHex === "function";
 };
-class UnexpectedResponseError extends Error {
-    constructor(response) {
-        super(`Unexpected response type. Got: ${JSON.stringify(response, null, 2)}`);
-        this.name = "UnexpectedResponseError";
+class ServiceWorkerReadonlyAssetManager {
+    constructor(sendMessage, messageTag) {
+        this.sendMessage = sendMessage;
+        this.messageTag = messageTag;
+    }
+    async getAssetDetails(assetId) {
+        const message = {
+            tag: this.messageTag,
+            type: "GET_ASSET_DETAILS",
+            id: getRandomId(),
+            payload: { assetId },
+        };
+        const response = await this.sendMessage(message);
+        return response.payload.assetDetails;
+    }
+}
+class ServiceWorkerAssetManager extends ServiceWorkerReadonlyAssetManager {
+    async issue(params) {
+        const message = {
+            tag: this.messageTag,
+            type: "ISSUE",
+            id: getRandomId(),
+            payload: { params },
+        };
+        const response = await this.sendMessage(message);
+        return response.payload.result;
+    }
+    async reissue(params) {
+        const message = {
+            tag: this.messageTag,
+            type: "REISSUE",
+            id: getRandomId(),
+            payload: { params },
+        };
+        const response = await this.sendMessage(message);
+        return response.payload.txid;
+    }
+    async burn(params) {
+        const message = {
+            tag: this.messageTag,
+            type: "BURN",
+            id: getRandomId(),
+            payload: { params },
+        };
+        const response = await this.sendMessage(message);
+        return response.payload.txid;
     }
 }
-const createCommon = (options) => {
-    // Default to IndexedDB for service worker context
-    const storage = new IndexedDBStorageAdapter(options.dbName || DEFAULT_DB_NAME, options.dbVersion);
-    // Create repositories
-    return {
-        walletRepo: new WalletRepositoryImpl(storage),
-        contractRepo: new ContractRepositoryImpl(storage),
+const initializeMessageBus = (serviceWorker, config, timeoutMs = 2000) => {
+    const initCmd = {
+        tag: "INITIALIZE_MESSAGE_BUS",
+        id: getRandomId(),
+        config: { ...config, timeoutMs },
     };
+    return new Promise((resolve, reject) => {
+        const cleanup = () => {
+            navigator.serviceWorker.removeEventListener("message", onMessage);
+            clearTimeout(timeoutId);
+        };
+        const onMessage = (event) => {
+            const response = event.data;
+            if (response?.id !== initCmd.id)
+                return;
+            cleanup();
+            if (response.error) {
+                reject(response.error);
+            }
+            else {
+                resolve();
+            }
+        };
+        const timeoutId = setTimeout(() => {
+            cleanup();
+            reject(new Error("MessageBus timed out!"));
+        }, timeoutMs);
+        navigator.serviceWorker.addEventListener("message", onMessage);
+        serviceWorker.postMessage(initCmd);
+    });
 };
 export class ServiceWorkerReadonlyWallet {
-    constructor(serviceWorker, identity, walletRepository, contractRepository) {
+    get assetManager() {
+        return this._readonlyAssetManager;
+    }
+    constructor(serviceWorker, identity, walletRepository, contractRepository, messageTag) {
         this.serviceWorker = serviceWorker;
+        this.messageTag = messageTag;
         this.identity = identity;
         this.walletRepository = walletRepository;
         this.contractRepository = contractRepository;
+        this._readonlyAssetManager = new ServiceWorkerReadonlyAssetManager((msg) => this.sendMessage(msg), messageTag);
     }
     static async create(options) {
-        const { walletRepo, contractRepo } = createCommon(options);
+        const walletRepository = options.storage?.walletRepository ??
+            new IndexedDBWalletRepository();
+        const contractRepository = options.storage?.contractRepository ??
+            new IndexedDBContractRepository();
+        const messageTag = options.walletUpdaterTag ?? DEFAULT_MESSAGE_TAG;
         // Create the wallet instance
-        const wallet = new ServiceWorkerReadonlyWallet(options.serviceWorker, options.identity, walletRepo, contractRepo);
+        const wallet = new ServiceWorkerReadonlyWallet(options.serviceWorker, options.identity, walletRepository, contractRepository, messageTag);
         const publicKey = await options.identity
             .compressedPublicKey()
             .then(hex.encode);
-        // Initialize the service worker with the config
-        const initMessage = {
-            type: "INIT_WALLET",
-            id: getRandomId(),
+        const initConfig = {
             key: { publicKey },
             arkServerUrl: options.arkServerUrl,
             arkServerPublicKey: options.arkServerPublicKey,
+            delegatorUrl: options.delegatorUrl,
+        };
+        // Bootstrap the MessageBus in the service worker
+        await initializeMessageBus(options.serviceWorker, {
+            wallet: initConfig.key,
+            arkServer: {
+                url: initConfig.arkServerUrl,
+                publicKey: initConfig.arkServerPublicKey,
+            },
+            timeoutMs: options.messageBusTimeoutMs,
+        }, options.messageBusTimeoutMs);
+        // Initialize the wallet handler
+        const initMessage = {
+            tag: messageTag,
+            type: "INIT_WALLET",
+            id: getRandomId(),
+            payload: initConfig,
         };
-        // Initialize the service worker
         await wallet.sendMessage(initMessage);
         return wallet;
     }
@@ -73,44 +158,41 @@ export class ServiceWorkerReadonlyWallet {
         // Register and setup the service worker
         const serviceWorker = await setupServiceWorker(options.serviceWorkerPath);
         // Use the existing create method
-        return ServiceWorkerReadonlyWallet.create({
+        return await ServiceWorkerReadonlyWallet.create({
             ...options,
             serviceWorker,
         });
     }
     // send a message and wait for a response
-    async sendMessage(message) {
+    async sendMessage(request) {
         return new Promise((resolve, reject) => {
             const messageHandler = (event) => {
                 const response = event.data;
-                if (response.id === "") {
-                    reject(new Error("Invalid response id"));
-                    return;
-                }
-                if (response.id !== message.id) {
+                if (request.id !== response.id) {
                     return;
                 }
                 navigator.serviceWorker.removeEventListener("message", messageHandler);
-                if (!response.success) {
-                    reject(new Error(response.message));
+                if (response.error) {
+                    reject(response.error);
                 }
                 else {
                     resolve(response);
                 }
             };
             navigator.serviceWorker.addEventListener("message", messageHandler);
-            this.serviceWorker.postMessage(message);
+            this.serviceWorker.postMessage(request);
         });
     }
     async clear() {
         const message = {
-            type: "CLEAR",
             id: getRandomId(),
+            tag: this.messageTag,
+            type: "CLEAR",
         };
         // Clear page-side storage to maintain parity with SW
         try {
             const address = await this.getAddress();
-            await this.walletRepository.clearVtxos(address);
+            await this.walletRepository.deleteVtxos(address);
         }
         catch (_) {
             console.warn("Failed to clear vtxos from wallet repository");
@@ -119,15 +201,13 @@ export class ServiceWorkerReadonlyWallet {
     }
     async getAddress() {
         const message = {
-            type: "GET_ADDRESS",
             id: getRandomId(),
+            tag: this.messageTag,
+            type: "GET_ADDRESS",
         };
         try {
             const response = await this.sendMessage(message);
-            if (Response.isAddress(response)) {
-                return response.address;
-            }
-            throw new UnexpectedResponseError(response);
+            return response.payload.address;
         }
         catch (error) {
             throw new Error(`Failed to get address: ${error}`);
@@ -135,15 +215,13 @@ export class ServiceWorkerReadonlyWallet {
     }
     async getBoardingAddress() {
         const message = {
-            type: "GET_BOARDING_ADDRESS",
             id: getRandomId(),
+            tag: this.messageTag,
+            type: "GET_BOARDING_ADDRESS",
         };
         try {
             const response = await this.sendMessage(message);
-            if (Response.isBoardingAddress(response)) {
-                return response.address;
-            }
-            throw new UnexpectedResponseError(response);
+            return response.payload.address;
         }
         catch (error) {
             throw new Error(`Failed to get boarding address: ${error}`);
@@ -151,15 +229,13 @@ export class ServiceWorkerReadonlyWallet {
     }
     async getBalance() {
         const message = {
-            type: "GET_BALANCE",
             id: getRandomId(),
+            tag: this.messageTag,
+            type: "GET_BALANCE",
         };
         try {
             const response = await this.sendMessage(message);
-            if (Response.isBalance(response)) {
-                return response.balance;
-            }
-            throw new UnexpectedResponseError(response);
+            return response.payload;
         }
         catch (error) {
             throw new Error(`Failed to get balance: ${error}`);
@@ -167,15 +243,13 @@ export class ServiceWorkerReadonlyWallet {
     }
     async getBoardingUtxos() {
         const message = {
-            type: "GET_BOARDING_UTXOS",
             id: getRandomId(),
+            tag: this.messageTag,
+            type: "GET_BOARDING_UTXOS",
         };
         try {
             const response = await this.sendMessage(message);
-            if (Response.isBoardingUtxos(response)) {
-                return response.boardingUtxos;
-            }
-            throw new UnexpectedResponseError(response);
+            return response.payload.utxos;
         }
         catch (error) {
             throw new Error(`Failed to get boarding UTXOs: ${error}`);
@@ -183,26 +257,28 @@ export class ServiceWorkerReadonlyWallet {
     }
     async getStatus() {
         const message = {
-            type: "GET_STATUS",
             id: getRandomId(),
+            tag: this.messageTag,
+            type: "GET_STATUS",
         };
-        const response = await this.sendMessage(message);
-        if (Response.isWalletStatus(response)) {
-            return response.status;
+        try {
+            const response = await this.sendMessage(message);
+            return response.payload;
+        }
+        catch (error) {
+            throw new Error(`Failed to get status: ${error}`);
         }
-        throw new UnexpectedResponseError(response);
     }
     async getTransactionHistory() {
         const message = {
-            type: "GET_TRANSACTION_HISTORY",
             id: getRandomId(),
+            tag: this.messageTag,
+            type: "GET_TRANSACTION_HISTORY",
         };
         try {
             const response = await this.sendMessage(message);
-            if (Response.isTransactionHistory(response)) {
-                return response.transactions;
-            }
-            throw new UnexpectedResponseError(response);
+            return response.payload
+                .transactions;
         }
         catch (error) {
             throw new Error(`Failed to get transaction history: ${error}`);
@@ -210,16 +286,14 @@ export class ServiceWorkerReadonlyWallet {
     }
     async getVtxos(filter) {
         const message = {
-            type: "GET_VTXOS",
             id: getRandomId(),
-            filter,
+            tag: this.messageTag,
+            type: "GET_VTXOS",
+            payload: { filter },
         };
         try {
             const response = await this.sendMessage(message);
-            if (Response.isVtxos(response)) {
-                return response.vtxos;
-            }
-            throw new UnexpectedResponseError(response);
+            return response.payload.vtxos;
         }
         catch (error) {
             throw new Error(`Failed to get vtxos: ${error}`);
@@ -227,26 +301,209 @@ export class ServiceWorkerReadonlyWallet {
     }
     async reload() {
         const message = {
-            type: "RELOAD_WALLET",
             id: getRandomId(),
+            tag: this.messageTag,
+            type: "RELOAD_WALLET",
         };
-        const response = await this.sendMessage(message);
-        if (Response.isWalletReloaded(response)) {
-            return response.success;
+        try {
+            const response = await this.sendMessage(message);
+            return response.payload.reloaded;
+        }
+        catch (error) {
+            throw new Error(`Failed to reload wallet: ${error}`);
         }
-        throw new UnexpectedResponseError(response);
+    }
+    async getContractManager() {
+        const wallet = this;
+        const sendContractMessage = async (message) => {
+            return wallet.sendMessage(message);
+        };
+        const messageTag = this.messageTag;
+        const manager = {
+            async createContract(params) {
+                const message = {
+                    type: "CREATE_CONTRACT",
+                    id: getRandomId(),
+                    tag: messageTag,
+                    payload: params,
+                };
+                try {
+                    const response = await sendContractMessage(message);
+                    return response.payload
+                        .contract;
+                }
+                catch (e) {
+                    throw new Error("Failed to create contract");
+                }
+            },
+            async getContracts(filter) {
+                const message = {
+                    type: "GET_CONTRACTS",
+                    id: getRandomId(),
+                    tag: messageTag,
+                    payload: { filter },
+                };
+                try {
+                    const response = await sendContractMessage(message);
+                    return response.payload.contracts;
+                }
+                catch (e) {
+                    throw new Error("Failed to get contracts");
+                }
+            },
+            async getContractsWithVtxos(filter) {
+                const message = {
+                    type: "GET_CONTRACTS_WITH_VTXOS",
+                    id: getRandomId(),
+                    tag: messageTag,
+                    payload: { filter },
+                };
+                try {
+                    const response = await sendContractMessage(message);
+                    return response.payload
+                        .contracts;
+                }
+                catch (e) {
+                    throw new Error("Failed to get contracts with vtxos");
+                }
+            },
+            async updateContract(script, updates) {
+                const message = {
+                    type: "UPDATE_CONTRACT",
+                    id: getRandomId(),
+                    tag: messageTag,
+                    payload: { script, updates },
+                };
+                try {
+                    const response = await sendContractMessage(message);
+                    return response.payload
+                        .contract;
+                }
+                catch (e) {
+                    throw new Error("Failed to update contract");
+                }
+            },
+            async setContractState(script, state) {
+                const message = {
+                    type: "UPDATE_CONTRACT",
+                    id: getRandomId(),
+                    tag: messageTag,
+                    payload: { script, updates: { state } },
+                };
+                try {
+                    await sendContractMessage(message);
+                    return;
+                }
+                catch (e) {
+                    throw new Error("Failed to update contract state");
+                }
+            },
+            async deleteContract(script) {
+                const message = {
+                    type: "DELETE_CONTRACT",
+                    id: getRandomId(),
+                    tag: messageTag,
+                    payload: { script },
+                };
+                try {
+                    await sendContractMessage(message);
+                    return;
+                }
+                catch (e) {
+                    throw new Error("Failed to delete contract");
+                }
+            },
+            async getSpendablePaths(options) {
+                const message = {
+                    type: "GET_SPENDABLE_PATHS",
+                    id: getRandomId(),
+                    tag: messageTag,
+                    payload: { options },
+                };
+                try {
+                    const response = await sendContractMessage(message);
+                    return response.payload
+                        .paths;
+                }
+                catch (e) {
+                    throw new Error("Failed to get spendable paths");
+                }
+            },
+            async getAllSpendingPaths(options) {
+                const message = {
+                    type: "GET_ALL_SPENDING_PATHS",
+                    id: getRandomId(),
+                    tag: messageTag,
+                    payload: { options },
+                };
+                try {
+                    const response = await sendContractMessage(message);
+                    return response.payload
+                        .paths;
+                }
+                catch (e) {
+                    throw new Error("Failed to get all spending paths");
+                }
+            },
+            onContractEvent(callback) {
+                const messageHandler = (event) => {
+                    const response = event.data;
+                    if (response.type !== "CONTRACT_EVENT") {
+                        return;
+                    }
+                    if (response.tag !== messageTag) {
+                        return;
+                    }
+                    callback(response.payload.event);
+                };
+                navigator.serviceWorker.addEventListener("message", messageHandler);
+                return () => {
+                    navigator.serviceWorker.removeEventListener("message", messageHandler);
+                };
+            },
+            async isWatching() {
+                const message = {
+                    type: "IS_CONTRACT_MANAGER_WATCHING",
+                    id: getRandomId(),
+                    tag: messageTag,
+                };
+                try {
+                    const response = await sendContractMessage(message);
+                    return response
+                        .payload.isWatching;
+                }
+                catch (e) {
+                    throw new Error("Failed to check if contract manager is watching");
+                }
+            },
+            dispose() {
+                return;
+            },
+            [Symbol.dispose]() {
+                // no-op
+                return;
+            },
+        };
+        return manager;
     }
 }
 export class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet {
-    constructor(serviceWorker, identity, walletRepository, contractRepository) {
-        super(serviceWorker, identity, walletRepository, contractRepository);
+    constructor(serviceWorker, identity, walletRepository, contractRepository, messageTag) {
+        super(serviceWorker, identity, walletRepository, contractRepository, messageTag);
         this.serviceWorker = serviceWorker;
         this.identity = identity;
         this.walletRepository = walletRepository;
         this.contractRepository = contractRepository;
+        this._assetManager = new ServiceWorkerAssetManager((msg) => this.sendMessage(msg), messageTag);
+    }
+    get assetManager() {
+        return this._assetManager;
     }
     static async create(options) {
-        const { walletRepo, contractRepo } = createCommon(options);
+        const walletRepository = options.storage?.walletRepository ??
+            new IndexedDBWalletRepository();
+        const contractRepository = options.storage?.contractRepository ??
+            new IndexedDBContractRepository();
         // Extract identity and check if it can expose private key
         const identity = isPrivateKeyIdentity(options.identity)
             ? options.identity
@@ -256,15 +513,29 @@ export class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet {
         }
         // Extract private key for service worker initialization
         const privateKey = identity.toHex();
+        const messageTag = options.walletUpdaterTag ?? DEFAULT_MESSAGE_TAG;
         // Create the wallet instance
-        const wallet = new ServiceWorkerWallet(options.serviceWorker, identity, walletRepo, contractRepo);
+        const wallet = new ServiceWorkerWallet(options.serviceWorker, identity, walletRepository, contractRepository, messageTag);
+        const initConfig = {
+            key: { privateKey },
+            arkServerUrl: options.arkServerUrl,
+            arkServerPublicKey: options.arkServerPublicKey,
+            delegatorUrl: options.delegatorUrl,
+        };
+        await initializeMessageBus(options.serviceWorker, {
+            wallet: initConfig.key,
+            arkServer: {
+                url: initConfig.arkServerUrl,
+                publicKey: initConfig.arkServerPublicKey,
+            },
+            timeoutMs: options.messageBusTimeoutMs,
+        }, options.messageBusTimeoutMs);
         // Initialize the service worker with the config
         const initMessage = {
+            tag: messageTag,
             type: "INIT_WALLET",
             id: getRandomId(),
-            key: { privateKey },
-            arkServerUrl: options.arkServerUrl,
-            arkServerPublicKey: options.arkServerPublicKey,
+            payload: initConfig,
         };
         // Initialize the service worker
         await wallet.sendMessage(initMessage);
@@ -302,16 +573,14 @@ export class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet {
     }
     async sendBitcoin(params) {
         const message = {
-            type: "SEND_BITCOIN",
-            params,
             id: getRandomId(),
+            tag: this.messageTag,
+            type: "SEND_BITCOIN",
+            payload: params,
         };
         try {
             const response = await this.sendMessage(message);
-            if (Response.isSendBitcoinSuccess(response)) {
-                return response.txid;
-            }
-            throw new UnexpectedResponseError(response);
+            return response.payload.txid;
         }
         catch (error) {
             throw new Error(`Failed to send bitcoin: ${error}`);
@@ -319,9 +588,10 @@ export class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet {
     }
     async settle(params, callback) {
         const message = {
-            type: "SETTLE",
-            params,
             id: getRandomId(),
+            tag: this.messageTag,
+            type: "SETTLE",
+            payload: { params },
         };
         try {
             return new Promise((resolve, reject) => {
@@ -330,23 +600,23 @@ export class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet {
                     if (response.id !== message.id) {
                         return;
                     }
-                    if (!response.success) {
+                    if (response.error) {
                         navigator.serviceWorker.removeEventListener("message", messageHandler);
-                        reject(new Error(response.message));
+                        reject(response.error);
                         return;
                     }
                     switch (response.type) {
                         case "SETTLE_EVENT":
                             if (callback) {
-                                callback(response.event);
+                                callback(response.payload);
                             }
                             break;
                         case "SETTLE_SUCCESS":
                             navigator.serviceWorker.removeEventListener("message", messageHandler);
-                            resolve(response.txid);
+                            resolve(response.payload.txid);
                             break;
                         default:
-                            break;
+                            console.error(`Unexpected response type for SETTLE request: ${response.type}`);
                     }
                 };
                 navigator.serviceWorker.addEventListener("message", messageHandler);
@@ -357,8 +627,19 @@ export class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet {
             throw new Error(`Settlement failed: ${error}`);
         }
     }
-}
-function getRandomId() {
-    const randomValue = crypto.getRandomValues(new Uint8Array(16));
-    return hex.encode(randomValue);
+    async send(...recipients) {
+        const message = {
+            tag: this.messageTag,
+            type: "SEND",
+            id: getRandomId(),
+            payload: { recipients },
+        };
+        try {
+            const response = await this.sendMessage(message);
+            return response.payload.txid;
+        }
+        catch (error) {
+            throw new Error(`Send failed: ${error}`);
+        }
+    }
 }