@arkade-os/sdk 0.2.2 → 0.3.0-alpha.0

package/dist/esm/storage/localStorage.js

@@ -0,0 +1,44 @@
+export class LocalStorageAdapter {
+    getSafeLocalStorage() {
+        try {
+            if (typeof window === "undefined" || !window.localStorage) {
+                return null;
+            }
+            // Test access to ensure localStorage is actually available
+            window.localStorage.length;
+            return window.localStorage;
+        }
+        catch {
+            // localStorage may throw in some environments (e.g., private browsing, disabled storage)
+            return null;
+        }
+    }
+    async getItem(key) {
+        const localStorage = this.getSafeLocalStorage();
+        if (!localStorage) {
+            throw new Error("localStorage is not available in this environment");
+        }
+        return localStorage.getItem(key);
+    }
+    async setItem(key, value) {
+        const localStorage = this.getSafeLocalStorage();
+        if (!localStorage) {
+            throw new Error("localStorage is not available in this environment");
+        }
+        localStorage.setItem(key, value);
+    }
+    async removeItem(key) {
+        const localStorage = this.getSafeLocalStorage();
+        if (!localStorage) {
+            throw new Error("localStorage is not available in this environment");
+        }
+        localStorage.removeItem(key);
+    }
+    async clear() {
+        const localStorage = this.getSafeLocalStorage();
+        if (!localStorage) {
+            throw new Error("localStorage is not available in this environment");
+        }
+        localStorage.clear();
+    }
+}

package/dist/esm/tree/signingSession.js

@@ -1,7 +1,7 @@
 import * as musig2 from '../musig2/index.js';
 import { Script, SigHash } from "@scure/btc-signer";
 import { hex } from "@scure/base";
-import { schnorr, secp256k1 } from "@noble/curves/secp256k1";
+import { schnorr, secp256k1 } from "@noble/curves/secp256k1.js";
 import { randomPrivateKeyBytes, sha256x2 } from "@scure/btc-signer/utils";
 import { CosignerPublicKey, getArkPsbtFields } from '../utils/unknownFields.js';
 export const ErrMissingVtxoGraph = new Error("missing vtxo graph");

package/dist/esm/wallet/onchain.js

@@ -13,7 +13,7 @@ import { TxWeightEstimator } from '../utils/txSizeEstimator.js';
  *
  * @example
  * ```typescript
- * const wallet = new OnchainWallet(identity, 'mainnet');
+ * const wallet = await OnchainWallet.create(identity, 'mainnet');
  * const balance = await wallet.getBalance();
  * const txid = await wallet.send({
  *   address: 'bc1...',
@@ -22,15 +22,21 @@ import { TxWeightEstimator } from '../utils/txSizeEstimator.js';
  * ```
  */
 export class OnchainWallet {
-    constructor(identity, network, provider) {
+    constructor(identity, network, onchainP2TR, provider) {
         this.identity = identity;
-        const pubkey = identity.xOnlyPublicKey();
+        this.network = network;
+        this.onchainP2TR = onchainP2TR;
+        this.provider = provider;
+    }
+    static async create(identity, networkName, provider) {
+        const pubkey = await identity.xOnlyPublicKey();
         if (!pubkey) {
             throw new Error("Invalid configured public key");
         }
-        this.provider = provider || new EsploraProvider(ESPLORA_URL[network]);
-        this.network = getNetwork(network);
-        this.onchainP2TR = p2tr(pubkey, undefined, this.network);
+        const network = getNetwork(networkName);
+        const onchainProvider = provider || new EsploraProvider(ESPLORA_URL[networkName]);
+        const onchainP2TR = p2tr(pubkey, undefined, network);
+        return new OnchainWallet(identity, network, onchainP2TR, onchainProvider);
     }
     get address() {
         return this.onchainP2TR.address || "";

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

@@ -9,13 +9,13 @@ export var Request;
     Request.isBase = isBase;
     function isInitWallet(message) {
         return (message.type === "INIT_WALLET" &&
-            "privateKey" in message &&
-            typeof message.privateKey === "string" &&
             "arkServerUrl" in message &&
             typeof message.arkServerUrl === "string" &&
+            "privateKey" in message &&
+            typeof message.privateKey === "string" &&
             ("arkServerPublicKey" in message
-                ? typeof message.arkServerPublicKey === "string" ||
-                    message.arkServerPublicKey === undefined
+                ? message.arkServerPublicKey === undefined ||
+                    typeof message.arkServerPublicKey === "string"
                 : true));
     }
     Request.isInitWallet = isInitWallet;
@@ -66,14 +66,4 @@ export var Request;
         return message.type === "GET_STATUS";
     }
     Request.isGetStatus = isGetStatus;
-    function isSign(message) {
-        return (message.type === "SIGN" &&
-            "tx" in message &&
-            typeof message.tx === "string" &&
-            ("inputIndexes" in message && message.inputIndexes != undefined
-                ? Array.isArray(message.inputIndexes) &&
-                    message.inputIndexes.every((index) => typeof index === "number")
-                : true));
-    }
-    Request.isSign = isSign;
 })(Request || (Request = {}));

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

@@ -172,17 +172,4 @@ export var Response;
         };
     }
     Response.clearResponse = clearResponse;
-    function signSuccess(id, tx) {
-        return {
-            type: "SIGN_SUCCESS",
-            success: true,
-            tx,
-            id,
-        };
-    }
-    Response.signSuccess = signSuccess;
-    function isSignSuccess(response) {
-        return response.type === "SIGN_SUCCESS" && response.success === true;
-    }
-    Response.isSignSuccess = isSignSuccess;
 })(Response || (Response = {}));

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

@@ -1,92 +1,90 @@
 import { Response } from './response.js';
-import { base64, hex } from "@scure/base";
-import { SingleKey } from '../../identity/singleKey.js';
-import { TreeSignerSession } from '../../tree/signingSession.js';
-import { Transaction } from "@scure/btc-signer";
+import { hex } from "@scure/base";
+import { IndexedDBStorageAdapter } from '../../storage/indexedDB.js';
+import { WalletRepositoryImpl } from '../../repositories/walletRepository.js';
+import { ContractRepositoryImpl } from '../../repositories/contractRepository.js';
+import { setupServiceWorker } from './utils.js';
+const isPrivateKeyIdentity = (identity) => {
+    return (identity.toHex !== undefined &&
+        typeof identity.toHex === "function" &&
+        typeof identity.toHex() === "string" &&
+        identity.toHex().length > 0);
+};
 class UnexpectedResponseError extends Error {
     constructor(response) {
         super(`Unexpected response type. Got: ${JSON.stringify(response, null, 2)}`);
         this.name = "UnexpectedResponseError";
     }
 }
-/**
- * Service Worker-based wallet implementation for browser environments.
- *
- * This wallet uses a service worker as a backend to handle wallet logic,
- * providing secure key storage and transaction signing in web applications.
- * The service worker runs in a separate thread and can persist data between
- * browser sessions.
- *
- * @example
- * ```typescript
- * // Create and initialize the service worker wallet
- * const serviceWorker = await setupServiceWorker("/service-worker.js");
- * const wallet = new ServiceWorkerWallet(serviceWorker);
- * await wallet.init({
- *   privateKey: 'your_private_key_hex',
- *   arkServerUrl: 'https://ark.example.com'
- * });
- *
- * // Use like any other wallet
- * const address = await wallet.getAddress();
- * const balance = await wallet.getBalance();
- * ```
- */
 export class ServiceWorkerWallet {
-    constructor(serviceWorker) {
+    constructor(serviceWorker, identity, walletRepository, contractRepository) {
         this.serviceWorker = serviceWorker;
+        this.identity = identity;
+        this.walletRepository = walletRepository;
+        this.contractRepository = contractRepository;
     }
-    async getStatus() {
-        const message = {
-            type: "GET_STATUS",
-            id: getRandomId(),
-        };
-        const response = await this.sendMessage(message);
-        if (Response.isWalletStatus(response)) {
-            const { walletInitialized, xOnlyPublicKey } = response.status;
-            if (walletInitialized)
-                this.cachedXOnlyPublicKey = xOnlyPublicKey;
-            return response.status;
-        }
-        throw new UnexpectedResponseError(response);
-    }
-    async init(config, failIfInitialized = false) {
-        // Check if wallet is already initialized
-        const statusMessage = {
-            type: "GET_STATUS",
-            id: getRandomId(),
-        };
-        const response = await this.sendMessage(statusMessage);
-        if (Response.isWalletStatus(response) &&
-            response.status.walletInitialized) {
-            if (failIfInitialized) {
-                throw new Error("Wallet already initialized");
-            }
-            this.cachedXOnlyPublicKey = response.status.xOnlyPublicKey;
-            return;
+    static async create(options) {
+        // Default to IndexedDB for service worker context
+        const storage = options.storage || new IndexedDBStorageAdapter("wallet-db");
+        // Create repositories
+        const walletRepo = new WalletRepositoryImpl(storage);
+        const contractRepo = new ContractRepositoryImpl(storage);
+        // Extract identity and check if it can expose private key
+        const identity = isPrivateKeyIdentity(options.identity)
+            ? options.identity
+            : null;
+        if (!identity) {
+            throw new Error("ServiceWorkerWallet.create() requires a Identity that can expose its private key");
         }
-        // If not initialized, proceed with initialization
-        const message = {
+        // Extract private key for service worker initialization
+        const privateKey = identity.toHex();
+        // Create the wallet instance
+        const wallet = new ServiceWorkerWallet(options.serviceWorker, identity, walletRepo, contractRepo);
+        // Initialize the service worker with the config
+        const initMessage = {
             type: "INIT_WALLET",
             id: getRandomId(),
-            privateKey: config.privateKey,
-            arkServerUrl: config.arkServerUrl,
-            arkServerPublicKey: config.arkServerPublicKey,
+            privateKey,
+            arkServerUrl: options.arkServerUrl,
+            arkServerPublicKey: options.arkServerPublicKey,
         };
-        await this.sendMessage(message);
-        const privKeyBytes = hex.decode(config.privateKey);
-        // cache the identity xOnlyPublicKey
-        this.cachedXOnlyPublicKey =
-            SingleKey.fromPrivateKey(privKeyBytes).xOnlyPublicKey();
+        // Initialize the service worker
+        await wallet.sendMessage(initMessage);
+        return wallet;
     }
-    async clear() {
-        const message = {
-            type: "CLEAR",
-            id: getRandomId(),
-        };
-        await this.sendMessage(message);
-        // clear the cached xOnlyPublicKey
-        this.cachedXOnlyPublicKey = undefined;
+    /**
+     * Simplified setup method that handles service worker registration,
+     * identity creation, and wallet initialization automatically.
+     *
+     * @example
+     * ```typescript
+     * // One-liner setup - handles everything automatically!
+     * const wallet = await ServiceWorkerWallet.setup({
+     *   serviceWorkerPath: '/service-worker.js',
+     *   arkServerUrl: 'https://mutinynet.arkade.sh'
+     * });
+     *
+     * // With custom identity
+     * const identity = SingleKey.fromHex('your_private_key_hex');
+     * const wallet = await ServiceWorkerWallet.setup({
+     *   serviceWorkerPath: '/service-worker.js',
+     *   arkServerUrl: 'https://mutinynet.arkade.sh',
+     *   identity
+     * });
+     * ```
+     */
+    static async setup(options) {
+        // Register and setup the service worker
+        const serviceWorker = await setupServiceWorker(options.serviceWorkerPath);
+        // Use the existing create method
+        return await ServiceWorkerWallet.create({
+            arkServerPublicKey: options.arkServerPublicKey,
+            arkServerUrl: options.arkServerUrl,
+            esploraUrl: options.esploraUrl,
+            identity: options.identity,
+            serviceWorker,
+            storage: options.storage,
+        });
     }
     // send a message and wait for a response
     async sendMessage(message) {
@@ -112,6 +110,21 @@ export class ServiceWorkerWallet {
             this.serviceWorker.postMessage(message);
         });
     }
+    async clear() {
+        const message = {
+            type: "CLEAR",
+            id: getRandomId(),
+        };
+        // Clear page-side storage to maintain parity with SW
+        try {
+            const address = await this.getAddress();
+            await this.walletRepository.clearVtxos(address);
+        }
+        catch (_) {
+            console.warn("Failed to clear vtxos from wallet repository");
+        }
+        await this.sendMessage(message);
+    }
     async getAddress() {
         const message = {
             type: "GET_ADDRESS",
@@ -160,37 +173,64 @@ export class ServiceWorkerWallet {
             throw new Error(`Failed to get balance: ${error}`);
         }
     }
-    async getVtxos(filter) {
+    async getBoardingUtxos() {
         const message = {
-            type: "GET_VTXOS",
+            type: "GET_BOARDING_UTXOS",
             id: getRandomId(),
-            filter,
         };
         try {
             const response = await this.sendMessage(message);
-            if (Response.isVtxos(response)) {
-                return response.vtxos;
+            if (Response.isBoardingUtxos(response)) {
+                return response.boardingUtxos;
             }
             throw new UnexpectedResponseError(response);
         }
         catch (error) {
-            throw new Error(`Failed to get vtxos: ${error}`);
+            throw new Error(`Failed to get boarding UTXOs: ${error}`);
         }
     }
-    async getBoardingUtxos() {
+    async getStatus() {
         const message = {
-            type: "GET_BOARDING_UTXOS",
+            type: "GET_STATUS",
+            id: getRandomId(),
+        };
+        const response = await this.sendMessage(message);
+        if (Response.isWalletStatus(response)) {
+            return response.status;
+        }
+        throw new UnexpectedResponseError(response);
+    }
+    async getTransactionHistory() {
+        const message = {
+            type: "GET_TRANSACTION_HISTORY",
             id: getRandomId(),
         };
         try {
             const response = await this.sendMessage(message);
-            if (Response.isBoardingUtxos(response)) {
-                return response.boardingUtxos;
+            if (Response.isTransactionHistory(response)) {
+                return response.transactions;
             }
             throw new UnexpectedResponseError(response);
         }
         catch (error) {
-            throw new Error(`Failed to get boarding UTXOs: ${error}`);
+            throw new Error(`Failed to get transaction history: ${error}`);
+        }
+    }
+    async getVtxos(filter) {
+        const message = {
+            type: "GET_VTXOS",
+            id: getRandomId(),
+            filter,
+        };
+        try {
+            const response = await this.sendMessage(message);
+            if (Response.isVtxos(response)) {
+                return response.vtxos;
+            }
+            throw new UnexpectedResponseError(response);
+        }
+        catch (error) {
+            throw new Error(`Failed to get vtxos: ${error}`);
         }
     }
     async sendBitcoin(params) {
@@ -247,52 +287,6 @@ export class ServiceWorkerWallet {
             throw new Error(`Settlement failed: ${error}`);
         }
     }
-    async getTransactionHistory() {
-        const message = {
-            type: "GET_TRANSACTION_HISTORY",
-            id: getRandomId(),
-        };
-        try {
-            const response = await this.sendMessage(message);
-            if (Response.isTransactionHistory(response)) {
-                return response.transactions;
-            }
-            throw new UnexpectedResponseError(response);
-        }
-        catch (error) {
-            throw new Error(`Failed to get transaction history: ${error}`);
-        }
-    }
-    xOnlyPublicKey() {
-        if (!this.cachedXOnlyPublicKey) {
-            throw new Error("Wallet not initialized");
-        }
-        return this.cachedXOnlyPublicKey;
-    }
-    signerSession() {
-        return TreeSignerSession.random();
-    }
-    async sign(tx, inputIndexes) {
-        const message = {
-            type: "SIGN",
-            tx: base64.encode(tx.toPSBT()),
-            inputIndexes,
-            id: getRandomId(),
-        };
-        try {
-            const response = await this.sendMessage(message);
-            if (Response.isSignSuccess(response)) {
-                return Transaction.fromPSBT(base64.decode(response.tx), {
-                    allowUnknown: true,
-                    allowUnknownInputs: true,
-                });
-            }
-            throw new UnexpectedResponseError(response);
-        }
-        catch (error) {
-            throw new Error(`Failed to sign: ${error}`);
-        }
-    }
 }
 function getRandomId() {
     const randomValue = crypto.getRandomValues(new Uint8Array(16));