@arkade-os/sdk 0.3.0-alpha.6 → 0.3.0-alpha.8

package/dist/esm/providers/expoArk.js

@@ -0,0 +1,200 @@
+import { RestArkProvider, isFetchTimeoutError, } from './ark.js';
+/**
+ * Expo-compatible Ark provider implementation using expo/fetch for SSE support.
+ * This provider works specifically in React Native/Expo environments where
+ * standard EventSource is not available but expo/fetch provides SSE capabilities.
+ *
+ * @example
+ * ```typescript
+ * import { ExpoArkProvider } from '@arkade-os/sdk/providers/expo';
+ *
+ * const provider = new ExpoArkProvider('https://ark.example.com');
+ * const info = await provider.getInfo();
+ * ```
+ */
+export class ExpoArkProvider extends RestArkProvider {
+    constructor(serverUrl) {
+        super(serverUrl);
+    }
+    async *getEventStream(signal, topics) {
+        // Dynamic import to avoid bundling expo/fetch in non-Expo environments
+        let expoFetch = fetch; // Default to standard fetch
+        try {
+            const expoFetchModule = await import("expo/fetch");
+            // expo/fetch returns a compatible fetch function but with different types
+            expoFetch = expoFetchModule.fetch;
+            console.debug("Using expo/fetch for SSE");
+        }
+        catch (error) {
+            // Fall back to standard fetch if expo/fetch is not available
+            console.warn("Using standard fetch instead of expo/fetch. " +
+                "Streaming may not be fully supported in some environments.", error);
+        }
+        const url = `${this.serverUrl}/v1/batch/events`;
+        const queryParams = topics.length > 0
+            ? `?${topics.map((topic) => `topics=${encodeURIComponent(topic)}`).join("&")}`
+            : "";
+        while (!signal?.aborted) {
+            // Create a new AbortController for this specific fetch attempt
+            // to prevent accumulating listeners on the parent signal
+            const fetchController = new AbortController();
+            const cleanup = () => fetchController.abort();
+            signal?.addEventListener("abort", cleanup, { once: true });
+            try {
+                const response = await expoFetch(url + queryParams, {
+                    headers: {
+                        Accept: "text/event-stream",
+                    },
+                    signal: fetchController.signal,
+                });
+                if (!response.ok) {
+                    throw new Error(`Unexpected status ${response.status} when fetching event stream`);
+                }
+                if (!response.body) {
+                    throw new Error("Response body is null");
+                }
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = "";
+                while (!signal?.aborted) {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                        break;
+                    }
+                    // Append new data to buffer and split by newlines
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split("\n");
+                    // Process all complete lines
+                    for (let i = 0; i < lines.length - 1; i++) {
+                        const line = lines[i].trim();
+                        if (!line)
+                            continue;
+                        try {
+                            // Parse SSE format: "data: {json}"
+                            if (line.startsWith("data:")) {
+                                const jsonStr = line.substring(5).trim();
+                                if (!jsonStr)
+                                    continue;
+                                const data = JSON.parse(jsonStr);
+                                // Handle different response structures
+                                // v8 mesh API might wrap in {result: ...} or send directly
+                                const eventData = data.result || data;
+                                // Skip heartbeat messages
+                                if (eventData.heartbeat !== undefined) {
+                                    continue;
+                                }
+                                const event = this.parseSettlementEvent(eventData);
+                                if (event) {
+                                    yield event;
+                                }
+                            }
+                        }
+                        catch (err) {
+                            console.error("Failed to parse event:", line);
+                            console.error("Parse error:", err);
+                            throw err;
+                        }
+                    }
+                    // Keep the last partial line in the buffer
+                    buffer = lines[lines.length - 1];
+                }
+            }
+            catch (error) {
+                if (error instanceof Error && error.name === "AbortError") {
+                    break;
+                }
+                // ignore timeout errors, they're expected when the server is not sending anything for 5 min
+                // these timeouts are set by expo/fetch function
+                if (isFetchTimeoutError(error)) {
+                    console.debug("Timeout error ignored");
+                    continue;
+                }
+                console.error("Event stream error:", error);
+                throw error;
+            }
+            finally {
+                // Clean up the abort listener
+                signal?.removeEventListener("abort", cleanup);
+            }
+        }
+    }
+    async *getTransactionsStream(signal) {
+        // Dynamic import to avoid bundling expo/fetch in non-Expo environments
+        let expoFetch = fetch; // Default to standard fetch
+        try {
+            const expoFetchModule = await import("expo/fetch");
+            // expo/fetch returns a compatible fetch function but with different types
+            expoFetch = expoFetchModule.fetch;
+            console.debug("Using expo/fetch for transaction stream");
+        }
+        catch (error) {
+            // Fall back to standard fetch if expo/fetch is not available
+            console.warn("Using standard fetch instead of expo/fetch. " +
+                "Streaming may not be fully supported in some environments.", error);
+        }
+        const url = `${this.serverUrl}/v1/txs`;
+        while (!signal?.aborted) {
+            // Create a new AbortController for this specific fetch attempt
+            // to prevent accumulating listeners on the parent signal
+            const fetchController = new AbortController();
+            const cleanup = () => fetchController.abort();
+            signal?.addEventListener("abort", cleanup, { once: true });
+            try {
+                const response = await expoFetch(url, {
+                    headers: {
+                        Accept: "text/event-stream",
+                    },
+                    signal: fetchController.signal,
+                });
+                if (!response.ok) {
+                    throw new Error(`Unexpected status ${response.status} when fetching transaction stream`);
+                }
+                if (!response.body) {
+                    throw new Error("Response body is null");
+                }
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = "";
+                while (!signal?.aborted) {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                        break;
+                    }
+                    // Append new data to buffer and split by newlines
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split("\n");
+                    // Process all complete lines
+                    for (let i = 0; i < lines.length - 1; i++) {
+                        const line = lines[i].trim();
+                        if (!line)
+                            continue;
+                        const data = JSON.parse(line);
+                        const txNotification = this.parseTransactionNotification(data.result);
+                        if (txNotification) {
+                            yield txNotification;
+                        }
+                    }
+                    // Keep the last partial line in the buffer
+                    buffer = lines[lines.length - 1];
+                }
+            }
+            catch (error) {
+                if (error instanceof Error && error.name === "AbortError") {
+                    break;
+                }
+                // ignore timeout errors, they're expected when the server is not sending anything for 5 min
+                // these timeouts are set by expo/fetch function
+                if (isFetchTimeoutError(error)) {
+                    console.debug("Timeout error ignored");
+                    continue;
+                }
+                console.error("Address subscription error:", error);
+                throw error;
+            }
+            finally {
+                // Clean up the abort listener
+                signal?.removeEventListener("abort", cleanup);
+            }
+        }
+    }
+}

package/dist/esm/providers/expoIndexer.js

@@ -0,0 +1,157 @@
+import { RestIndexerProvider } from './indexer.js';
+import { isFetchTimeoutError } from './ark.js';
+// Helper function to convert Vtxo to VirtualCoin (same as in indexer.ts)
+function convertVtxo(vtxo) {
+    return {
+        txid: vtxo.outpoint.txid,
+        vout: vtxo.outpoint.vout,
+        value: Number(vtxo.amount),
+        status: {
+            confirmed: !vtxo.isSwept && !vtxo.isPreconfirmed,
+        },
+        virtualStatus: {
+            state: vtxo.isSwept
+                ? "swept"
+                : vtxo.isPreconfirmed
+                    ? "preconfirmed"
+                    : "settled",
+            commitmentTxIds: vtxo.commitmentTxids,
+            batchExpiry: vtxo.expiresAt
+                ? Number(vtxo.expiresAt) * 1000
+                : undefined,
+        },
+        spentBy: vtxo.spentBy ?? "",
+        settledBy: vtxo.settledBy,
+        arkTxId: vtxo.arkTxid,
+        createdAt: new Date(Number(vtxo.createdAt) * 1000),
+        isUnrolled: vtxo.isUnrolled,
+        isSpent: vtxo.isSpent,
+    };
+}
+/**
+ * Expo-compatible Indexer provider implementation using expo/fetch for streaming support.
+ * This provider works specifically in React Native/Expo environments where
+ * standard fetch streaming may not work properly but expo/fetch provides streaming capabilities.
+ *
+ * @example
+ * ```typescript
+ * import { ExpoIndexerProvider } from '@arkade-os/sdk/adapters/expo';
+ *
+ * const provider = new ExpoIndexerProvider('https://indexer.example.com');
+ * const vtxos = await provider.getVtxos({ scripts: ['script1'] });
+ * ```
+ */
+export class ExpoIndexerProvider extends RestIndexerProvider {
+    constructor(serverUrl) {
+        super(serverUrl);
+    }
+    async *getSubscription(subscriptionId, abortSignal) {
+        // Detect if we're running in React Native/Expo environment
+        const isReactNative = typeof navigator !== "undefined" &&
+            navigator.product === "ReactNative";
+        // Dynamic import to avoid bundling expo/fetch in non-Expo environments
+        let expoFetch = fetch; // Default to standard fetch
+        try {
+            const expoFetchModule = await import("expo/fetch");
+            // expo/fetch returns a compatible fetch function but with different types
+            expoFetch = expoFetchModule.fetch;
+            console.debug("Using expo/fetch for indexer subscription");
+        }
+        catch (error) {
+            // In React Native/Expo, expo/fetch is required for proper streaming support
+            if (isReactNative) {
+                throw new Error("expo/fetch is unavailable in React Native environment. " +
+                    "Please ensure expo/fetch is installed and properly configured. " +
+                    "Streaming support may not work with standard fetch in React Native.");
+            }
+            // In non-RN environments, fall back to standard fetch but warn about potential streaming issues
+            console.warn("Using standard fetch instead of expo/fetch. " +
+                "Streaming may not be fully supported in some environments.", error);
+        }
+        const url = `${this.serverUrl}/v1/indexer/script/subscription/${subscriptionId}`;
+        while (!abortSignal.aborted) {
+            try {
+                const res = await expoFetch(url, {
+                    headers: {
+                        Accept: "text/event-stream",
+                        "Content-Type": "application/json",
+                    },
+                    signal: abortSignal,
+                });
+                if (!res.ok) {
+                    throw new Error(`Unexpected status ${res.status} when subscribing to address updates`);
+                }
+                // Check if response is the expected content type
+                const contentType = res.headers.get("content-type");
+                if (contentType &&
+                    !contentType.includes("text/event-stream") &&
+                    !contentType.includes("application/json")) {
+                    throw new Error(`Unexpected content-type: ${contentType}. Expected text/event-stream or application/json`);
+                }
+                if (!res.body) {
+                    throw new Error("Response body is null");
+                }
+                const reader = res.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = "";
+                while (!abortSignal.aborted) {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                        break;
+                    }
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split("\n");
+                    for (let i = 0; i < lines.length - 1; i++) {
+                        const line = lines[i].trim();
+                        if (!line)
+                            continue;
+                        try {
+                            // Parse SSE format: "data: {json}"
+                            if (line.startsWith("data:")) {
+                                const jsonStr = line.substring(5).trim();
+                                if (!jsonStr)
+                                    continue;
+                                const data = JSON.parse(jsonStr);
+                                // Handle new v8 proto format with heartbeat or event
+                                if (data.heartbeat !== undefined) {
+                                    // Skip heartbeat messages
+                                    continue;
+                                }
+                                // Process event messages
+                                if (data.event) {
+                                    yield {
+                                        txid: data.event.txid,
+                                        scripts: data.event.scripts || [],
+                                        newVtxos: (data.event.newVtxos || []).map(convertVtxo),
+                                        spentVtxos: (data.event.spentVtxos || []).map(convertVtxo),
+                                        sweptVtxos: (data.event.sweptVtxos || []).map(convertVtxo),
+                                        tx: data.event.tx,
+                                        checkpointTxs: data.event.checkpointTxs,
+                                    };
+                                }
+                            }
+                        }
+                        catch (parseError) {
+                            console.error("Failed to parse subscription response:", parseError);
+                            throw parseError;
+                        }
+                    }
+                    buffer = lines[lines.length - 1];
+                }
+            }
+            catch (error) {
+                if (error instanceof Error && error.name === "AbortError") {
+                    break;
+                }
+                // ignore timeout errors, they're expected when the server is not sending anything for 5 min
+                // these timeouts are set by expo/fetch function
+                if (isFetchTimeoutError(error)) {
+                    console.debug("Timeout error ignored");
+                    continue;
+                }
+                console.error("Subscription error:", error);
+                throw error;
+            }
+        }
+    }
+}

package/dist/esm/providers/indexer.js

@@ -173,6 +173,7 @@ export class RestIndexerProvider {
                                     scripts: data.event.scripts || [],
                                     newVtxos: (data.event.newVtxos || []).map(convertVtxo),
                                     spentVtxos: (data.event.spentVtxos || []).map(convertVtxo),
+                                    sweptVtxos: (data.event.sweptVtxos || []).map(convertVtxo),
                                     tx: data.event.tx,
                                     checkpointTxs: data.event.checkpointTxs,
                                 };
@@ -326,7 +327,7 @@ export class RestIndexerProvider {
         });
         if (!res.ok) {
             const errorText = await res.text();
-            throw new Error(`Failed to unsubscribe to scripts: ${errorText}`);
+            console.warn(`Failed to unsubscribe to scripts: ${errorText}`);
         }
     }
 }
@@ -354,6 +355,7 @@ function convertVtxo(vtxo) {
         arkTxId: vtxo.arkTxid,
         createdAt: new Date(Number(vtxo.createdAt) * 1000),
         isUnrolled: vtxo.isUnrolled,
+        isSpent: vtxo.isSpent,
     };
 }
 // Unexported namespace for type guards only

package/dist/esm/script/base.js

@@ -1,9 +1,11 @@
-import { Address, p2tr, TAP_LEAF_VERSION, taprootListToTree, } from "@scure/btc-signer/payment.js";
+import { Script, Address, p2tr, taprootListToTree } from "@scure/btc-signer";
+import { TAP_LEAF_VERSION } from "@scure/btc-signer/payment.js";
+import { PSBTOutput } from "@scure/btc-signer/psbt.js";
 import { TAPROOT_UNSPENDABLE_KEY, } from "@scure/btc-signer/utils.js";
-import { ArkAddress } from './address.js';
-import { Script } from "@scure/btc-signer/script.js";
 import { hex } from "@scure/base";
+import { ArkAddress } from './address.js';
 import { ConditionCSVMultisigTapscript, CSVMultisigTapscript, } from './tapscript.js';
+const TapTreeCoder = PSBTOutput.tapTree[2];
 export function scriptFromTapLeafScript(leaf) {
     return leaf[1].subarray(0, leaf[1].length - 1); // remove the version byte
 }
@@ -17,8 +19,9 @@ export function scriptFromTapLeafScript(leaf) {
  */
 export class VtxoScript {
     static decode(tapTree) {
-        const leaves = decodeTaprootTree(tapTree);
-        return new VtxoScript(leaves);
+        const leaves = TapTreeCoder.decode(tapTree);
+        const scripts = leaves.map((leaf) => leaf.script);
+        return new VtxoScript(scripts);
     }
     constructor(scripts) {
         this.scripts = scripts;
@@ -32,7 +35,11 @@ export class VtxoScript {
         this.tweakedPublicKey = payment.tweakedPubkey;
     }
     encode() {
-        const tapTree = encodeTaprootTree(this.scripts);
+        const tapTree = TapTreeCoder.encode(this.scripts.map((script) => ({
+            depth: 1,
+            version: TAP_LEAF_VERSION,
+            script,
+        })));
         return tapTree;
     }
     address(prefix, serverPubKey) {
@@ -75,89 +82,3 @@ export class VtxoScript {
         return paths;
     }
 }
-function decodeTaprootTree(tapTree) {
-    let offset = 0;
-    const scripts = [];
-    // Read number of leaves
-    const [numLeaves, numLeavesSize] = decodeCompactSizeUint(tapTree, offset);
-    offset += numLeavesSize;
-    // Read each leaf
-    for (let i = 0; i < numLeaves; i++) {
-        // Skip depth (1 byte)
-        offset += 1;
-        // Skip leaf version (1 byte)
-        offset += 1;
-        // Read script length
-        const [scriptLength, scriptLengthSize] = decodeCompactSizeUint(tapTree, offset);
-        offset += scriptLengthSize;
-        // Read script content
-        const script = tapTree.slice(offset, offset + scriptLength);
-        scripts.push(script);
-        offset += scriptLength;
-    }
-    return scripts;
-}
-function decodeCompactSizeUint(data, offset) {
-    const firstByte = data[offset];
-    if (firstByte < 0xfd) {
-        return [firstByte, 1];
-    }
-    else if (firstByte === 0xfd) {
-        const value = new DataView(data.buffer).getUint16(offset + 1, true);
-        return [value, 3];
-    }
-    else if (firstByte === 0xfe) {
-        const value = new DataView(data.buffer).getUint32(offset + 1, true);
-        return [value, 5];
-    }
-    else {
-        const value = Number(new DataView(data.buffer).getBigUint64(offset + 1, true));
-        return [value, 9];
-    }
-}
-function encodeTaprootTree(leaves) {
-    const chunks = [];
-    // Write number of leaves as compact size uint
-    chunks.push(encodeCompactSizeUint(leaves.length));
-    for (const tapscript of leaves) {
-        // Write depth (always 1 for now)
-        chunks.push(new Uint8Array([1]));
-        // Write leaf version (0xc0 for tapscript)
-        chunks.push(new Uint8Array([0xc0]));
-        // Write script length and script
-        chunks.push(encodeCompactSizeUint(tapscript.length));
-        chunks.push(tapscript);
-    }
-    // Concatenate all chunks
-    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const chunk of chunks) {
-        result.set(chunk, offset);
-        offset += chunk.length;
-    }
-    return result;
-}
-function encodeCompactSizeUint(value) {
-    if (value < 0xfd) {
-        return new Uint8Array([value]);
-    }
-    else if (value <= 0xffff) {
-        const buffer = new Uint8Array(3);
-        buffer[0] = 0xfd;
-        new DataView(buffer.buffer).setUint16(1, value, true);
-        return buffer;
-    }
-    else if (value <= 0xffffffff) {
-        const buffer = new Uint8Array(5);
-        buffer[0] = 0xfe;
-        new DataView(buffer.buffer).setUint32(1, value, true);
-        return buffer;
-    }
-    else {
-        const buffer = new Uint8Array(9);
-        buffer[0] = 0xff;
-        new DataView(buffer.buffer).setBigUint64(1, BigInt(value), true);
-        return buffer;
-    }
-}

package/dist/esm/utils/arkTransaction.js

@@ -1,5 +1,5 @@
 import { DEFAULT_SEQUENCE, Transaction, } from "@scure/btc-signer/transaction.js";
-import { CLTVMultisigTapscript, decodeTapscript } from '../script/tapscript.js';
+import { CLTVMultisigTapscript, decodeTapscript, } from '../script/tapscript.js';
 import { scriptFromTapLeafScript, VtxoScript, } from '../script/base.js';
 import { P2A } from './anchor.js';
 import { hex } from "@scure/base";
@@ -103,3 +103,15 @@ const nLocktimeMinSeconds = 500000000n;
 function isSeconds(locktime) {
     return locktime >= nLocktimeMinSeconds;
 }
+export function hasBoardingTxExpired(coin, boardingTimelock) {
+    if (!coin.status.block_time)
+        return false;
+    if (boardingTimelock.value === 0n)
+        return true;
+    if (boardingTimelock.type !== "blocks")
+        return false; // TODO: handle get chain tip
+    // validate expiry in terms of seconds
+    const now = BigInt(Math.floor(Date.now() / 1000));
+    const blockTime = BigInt(Math.floor(coin.status.block_time));
+    return blockTime + boardingTimelock.value <= now;
+}

package/dist/esm/wallet/index.js

@@ -4,7 +4,7 @@ export var TxType;
     TxType["TxReceived"] = "RECEIVED";
 })(TxType || (TxType = {}));
 export function isSpendable(vtxo) {
-    return vtxo.spentBy === undefined || vtxo.spentBy === "";
+    return !vtxo.isSpent;
 }
 export function isRecoverable(vtxo) {
     return vtxo.virtualStatus.state === "swept" && isSpendable(vtxo);

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

@@ -44,11 +44,3 @@ export async function setupServiceWorker(path) {
         navigator.serviceWorker.addEventListener("error", onError);
     });
 }
-export function extendVirtualCoin(wallet, vtxo) {
-    return {
-        ...vtxo,
-        forfeitTapLeafScript: wallet.offchainTapscript.forfeit(),
-        intentTapLeafScript: wallet.offchainTapscript.exit(),
-        tapTree: wallet.offchainTapscript.encode(),
-    };
-}

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

@@ -1,6 +1,6 @@
 /// <reference lib="webworker" />
 import { SingleKey } from '../../identity/singleKey.js';
-import { isSpendable, isSubdust } from '../index.js';
+import { isRecoverable, isSpendable, isSubdust } from '../index.js';
 import { Wallet } from '../wallet.js';
 import { Request } from './request.js';
 import { Response } from './response.js';
@@ -10,7 +10,7 @@ import { RestIndexerProvider } from '../../providers/indexer.js';
 import { hex } from "@scure/base";
 import { IndexedDBStorageAdapter } from '../../storage/indexedDB.js';
 import { WalletRepositoryImpl, } from '../../repositories/walletRepository.js';
-import { extendVirtualCoin } from './utils.js';
+import { extendVirtualCoin } from '../utils.js';
 /**
  * Worker is a class letting to interact with ServiceWorkerWallet from the client
  * it aims to be run in a service worker context
@@ -74,6 +74,8 @@ export class Worker {
             this.incomingFundsSubscription();
         // Clear storage - this replaces vtxoRepository.close()
         await this.storage.clear();
+        // Reset in-memory caches by recreating the repository
+        this.walletRepository = new WalletRepositoryImpl(this.storage);
         this.wallet = undefined;
         this.arkProvider = undefined;
         this.indexerProvider = undefined;
@@ -102,9 +104,6 @@ export class Worker {
         const txs = await this.wallet.getTransactionHistory();
         if (txs)
             await this.walletRepository.saveTransactions(address, txs);
-        // stop previous subscriptions if any
-        if (this.incomingFundsSubscription)
-            this.incomingFundsSubscription();
         // subscribe for incoming funds and notify all clients when new funds arrive
         this.incomingFundsSubscription = await this.wallet.notifyIncomingFunds(async (funds) => {
             if (funds.type === "vtxo") {
@@ -124,7 +123,7 @@ export class Worker {
                 // notify all clients about the vtxo update
                 this.sendMessageToAllClients("VTXO_UPDATE", JSON.stringify({ newVtxos, spentVtxos }));
             }
-            if (funds.type === "utxo" && funds.coins.length > 0) {
+            if (funds.type === "utxo") {
                 // notify all clients about the utxo update
                 this.sendMessageToAllClients("UTXO_UPDATE", JSON.stringify(funds.coins));
             }
@@ -355,17 +354,16 @@ export class Worker {
             if (!message.filter?.withRecoverable) {
                 if (!this.wallet)
                     throw new Error("Wallet not initialized");
-                // exclude subdust is we don't want recoverable
-                const dustAmount = this.wallet?.dustAmount;
-                vtxos =
-                    dustAmount == null
-                        ? vtxos
-                        : vtxos.filter((v) => !isSubdust(v, dustAmount));
-            }
-            if (message.filter?.withRecoverable) {
-                // get also swept and spendable vtxos
-                const sweptVtxos = await this.getSweptVtxos();
-                vtxos.push(...sweptVtxos.filter(isSpendable));
+                // exclude subdust and recoverable if we don't want recoverable
+                const notSubdust = (v) => {
+                    const dustAmount = this.wallet?.dustAmount;
+                    return dustAmount == null
+                        ? true
+                        : !isSubdust(v, dustAmount);
+                };
+                vtxos = vtxos
+                    .filter(notSubdust)
+                    .filter((v) => !isRecoverable(v));
             }
             event.source?.postMessage(Response.vtxos(message.id, vtxos));
         }
@@ -526,7 +524,6 @@ export class Worker {
     }
     async handleReloadWallet(event) {
         const message = event.data;
-        console.log("RELOAD_WALLET message received", message);
         if (!Request.isReloadWallet(message)) {
             console.error("Invalid RELOAD_WALLET message format", message);
             event.source?.postMessage(Response.error(message.id, "Invalid RELOAD_WALLET message format"));

package/dist/esm/wallet/utils.js

@@ -0,0 +1,8 @@
+export function extendVirtualCoin(wallet, vtxo) {
+    return {
+        ...vtxo,
+        forfeitTapLeafScript: wallet.offchainTapscript.forfeit(),
+        intentTapLeafScript: wallet.offchainTapscript.exit(),
+        tapTree: wallet.offchainTapscript.encode(),
+    };
+}