@arkade-os/sdk 0.3.0-alpha.1 → 0.3.0-alpha.4

package/dist/cjs/wallet/wallet.js

@@ -135,10 +135,8 @@ class Wallet {
         // Save tapscripts
         const offchainTapscript = bareVtxoTapscript;
         // the serverUnrollScript is the one used to create output scripts of the checkpoint transactions
-        const serverUnrollScript = tapscript_1.CSVMultisigTapscript.encode({
-            timelock: exitTimelock,
-            pubkeys: [serverPubKey],
-        });
+        const rawCheckpointExitClosure = base_1.hex.decode(info.checkpointExitClosure);
+        const serverUnrollScript = tapscript_1.CSVMultisigTapscript.decode(rawCheckpointExitClosure);
         // parse the server forfeit address
         // server is expecting funds to be sent to this address
         const forfeitAddress = (0, payment_js_1.Address)(network).decode(info.forfeitAddress);
@@ -204,8 +202,9 @@ class Wallet {
     }
     async getVtxos(filter) {
         const address = await this.getAddress();
-        // Try to get from cache first
-        const cachedVtxos = await this.walletRepository.getVtxos(address);
+        // Try to get from cache first first (optional fast path)
+        // const cachedVtxos = await this.walletRepository.getVtxos(address);
+        // if (cachedVtxos.length) return cachedVtxos;
         // For now, always fetch fresh data from provider and update cache
         // In future, we can add cache invalidation logic based on timestamps
         const spendableVtxos = await this.getVirtualCoins(filter);

package/dist/esm/identity/singleKey.js

@@ -1,4 +1,4 @@
-import { pubSchnorr, randomPrivateKeyBytes, sha256, } from "@scure/btc-signer/utils.js";
+import { pubECDSA, pubSchnorr, randomPrivateKeyBytes, sha256, } from "@scure/btc-signer/utils.js";
 import { hex } from "@scure/base";
 import { SigHash } from "@scure/btc-signer/transaction.js";
 import { TreeSignerSession } from '../tree/signingSession.js';
@@ -70,6 +70,9 @@ export class SingleKey {
         }
         return txCpy;
     }
+    compressedPublicKey() {
+        return Promise.resolve(pubECDSA(this.key, true));
+    }
     xOnlyPublicKey() {
         return Promise.resolve(pubSchnorr(this.key));
     }

package/dist/esm/providers/ark.js

@@ -1,4 +1,5 @@
 import { hex } from "@scure/base";
+import { eventSourceIterator } from './utils.js';
 export var SettlementEventType;
 (function (SettlementEventType) {
     SettlementEventType["BatchStarted"] = "batch_started";
@@ -41,6 +42,7 @@ export class RestArkProvider {
             vtxoMinAmount: BigInt(fromServer.vtxoMinAmount ?? 0),
             vtxoMaxAmount: BigInt(fromServer.vtxoMaxAmount ?? -1),
             boardingExitDelay: BigInt(fromServer.boardingExitDelay ?? 0),
+            checkpointExitClosure: fromServer.checkpointTapscript ?? "",
             marketHour: "marketHour" in fromServer && fromServer.marketHour != null
                 ? {
                     nextStartTime: BigInt(fromServer.marketHour.nextStartTime ?? 0),
@@ -215,39 +217,21 @@ export class RestArkProvider {
             : "";
         while (!signal?.aborted) {
             try {
-                const response = await fetch(url + queryParams, {
-                    headers: {
-                        Accept: "application/json",
-                    },
-                    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;
+                const eventSource = new EventSource(url + queryParams);
+                // Set up abort handling
+                const abortHandler = () => {
+                    eventSource.close();
+                };
+                signal?.addEventListener("abort", abortHandler);
+                try {
+                    for await (const event of eventSourceIterator(eventSource)) {
+                        if (signal?.aborted)
+                            break;
                         try {
-                            const data = JSON.parse(line);
-                            const event = this.parseSettlementEvent(data.result);
-                            if (event) {
-                                yield event;
+                            const data = JSON.parse(event.data);
+                            const settlementEvent = this.parseSettlementEvent(data);
+                            if (settlementEvent) {
+                                yield settlementEvent;
                             }
                         }
                         catch (err) {
@@ -255,8 +239,10 @@ export class RestArkProvider {
                             throw err;
                         }
                     }
-                    // Keep the last partial line in the buffer
-                    buffer = lines[lines.length - 1];
+                }
+                finally {
+                    signal?.removeEventListener("abort", abortHandler);
+                    eventSource.close();
                 }
             }
             catch (error) {
@@ -264,7 +250,6 @@ export class RestArkProvider {
                     break;
                 }
                 // ignore timeout errors, they're expected when the server is not sending anything for 5 min
-                // these timeouts are set by builtin fetch function
                 if (isFetchTimeoutError(error)) {
                     console.debug("Timeout error ignored");
                     continue;
@@ -278,42 +263,32 @@ export class RestArkProvider {
         const url = `${this.serverUrl}/v1/txs`;
         while (!signal?.aborted) {
             try {
-                const response = await fetch(url, {
-                    headers: {
-                        Accept: "application/json",
-                    },
-                    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;
+                const eventSource = new EventSource(url);
+                // Set up abort handling
+                const abortHandler = () => {
+                    eventSource.close();
+                };
+                signal?.addEventListener("abort", abortHandler);
+                try {
+                    for await (const event of eventSourceIterator(eventSource)) {
+                        if (signal?.aborted)
+                            break;
+                        try {
+                            const data = JSON.parse(event.data);
+                            const txNotification = this.parseTransactionNotification(data);
+                            if (txNotification) {
+                                yield txNotification;
+                            }
+                        }
+                        catch (err) {
+                            console.error("Failed to parse transaction notification:", err);
+                            throw err;
                         }
                     }
-                    // Keep the last partial line in the buffer
-                    buffer = lines[lines.length - 1];
+                }
+                finally {
+                    signal?.removeEventListener("abort", abortHandler);
+                    eventSource.close();
                 }
             }
             catch (error) {
@@ -321,12 +296,11 @@ export class RestArkProvider {
                     break;
                 }
                 // ignore timeout errors, they're expected when the server is not sending anything for 5 min
-                // these timeouts are set by builtin fetch function
                 if (isFetchTimeoutError(error)) {
                     console.debug("Timeout error ignored");
                     continue;
                 }
-                console.error("Address subscription error:", error);
+                console.error("Transaction stream error:", error);
                 throw error;
             }
         }
@@ -409,6 +383,10 @@ export class RestArkProvider {
                 signature: data.treeSignature.signature,
             };
         }
+        // Skip heartbeat events
+        if (data.heartbeat) {
+            return null;
+        }
         console.warn("Unknown event type:", data);
         return null;
     }
@@ -435,6 +413,10 @@ export class RestArkProvider {
                 },
             };
         }
+        // Skip heartbeat events
+        if (data.heartbeat) {
+            return null;
+        }
         console.warn("Unknown transaction notification type:", data);
         return null;
     }

package/dist/esm/providers/indexer.js

@@ -1,4 +1,5 @@
 import { isFetchTimeoutError } from './ark.js';
+import { eventSourceIterator } from './utils.js';
 export var IndexerTxType;
 (function (IndexerTxType) {
     IndexerTxType[IndexerTxType["INDEXER_TX_TYPE_UNSPECIFIED"] = 0] = "INDEXER_TX_TYPE_UNSPECIFIED";
@@ -27,7 +28,7 @@ export class RestIndexerProvider {
         this.serverUrl = serverUrl;
     }
     async getVtxoTree(batchOutpoint, opts) {
-        let url = `${this.serverUrl}/v1/batch/${batchOutpoint.txid}/${batchOutpoint.vout}/tree`;
+        let url = `${this.serverUrl}/v1/indexer/batch/${batchOutpoint.txid}/${batchOutpoint.vout}/tree`;
         const params = new URLSearchParams();
         if (opts) {
             if (opts.pageIndex !== undefined)
@@ -55,7 +56,7 @@ export class RestIndexerProvider {
         return data;
     }
     async getVtxoTreeLeaves(batchOutpoint, opts) {
-        let url = `${this.serverUrl}/v1/batch/${batchOutpoint.txid}/${batchOutpoint.vout}/tree/leaves`;
+        let url = `${this.serverUrl}/v1/indexer/batch/${batchOutpoint.txid}/${batchOutpoint.vout}/tree/leaves`;
         const params = new URLSearchParams();
         if (opts) {
             if (opts.pageIndex !== undefined)
@@ -77,7 +78,7 @@ export class RestIndexerProvider {
         return data;
     }
     async getBatchSweepTransactions(batchOutpoint) {
-        const url = `${this.serverUrl}/v1/batch/${batchOutpoint.txid}/${batchOutpoint.vout}/sweepTxs`;
+        const url = `${this.serverUrl}/v1/indexer/batch/${batchOutpoint.txid}/${batchOutpoint.vout}/sweepTxs`;
         const res = await fetch(url);
         if (!res.ok) {
             throw new Error(`Failed to fetch batch sweep transactions: ${res.statusText}`);
@@ -89,7 +90,7 @@ export class RestIndexerProvider {
         return data;
     }
     async getCommitmentTx(txid) {
-        const url = `${this.serverUrl}/v1/commitmentTx/${txid}`;
+        const url = `${this.serverUrl}/v1/indexer/commitmentTx/${txid}`;
         const res = await fetch(url);
         if (!res.ok) {
             throw new Error(`Failed to fetch commitment tx: ${res.statusText}`);
@@ -101,7 +102,7 @@ export class RestIndexerProvider {
         return data;
     }
     async getCommitmentTxConnectors(txid, opts) {
-        let url = `${this.serverUrl}/v1/commitmentTx/${txid}/connectors`;
+        let url = `${this.serverUrl}/v1/indexer/commitmentTx/${txid}/connectors`;
         const params = new URLSearchParams();
         if (opts) {
             if (opts.pageIndex !== undefined)
@@ -129,7 +130,7 @@ export class RestIndexerProvider {
         return data;
     }
     async getCommitmentTxForfeitTxs(txid, opts) {
-        let url = `${this.serverUrl}/v1/commitmentTx/${txid}/forfeitTxs`;
+        let url = `${this.serverUrl}/v1/indexer/commitmentTx/${txid}/forfeitTxs`;
         const params = new URLSearchParams();
         if (opts) {
             if (opts.pageIndex !== undefined)
@@ -151,47 +152,41 @@ export class RestIndexerProvider {
         return data;
     }
     async *getSubscription(subscriptionId, abortSignal) {
-        const url = `${this.serverUrl}/v1/script/subscription/${subscriptionId}`;
-        while (!abortSignal.aborted) {
+        const url = `${this.serverUrl}/v1/indexer/script/subscription/${subscriptionId}`;
+        while (!abortSignal?.aborted) {
             try {
-                const res = await fetch(url, {
-                    headers: {
-                        Accept: "application/json",
-                    },
-                });
-                if (!res.ok) {
-                    throw new Error(`Unexpected status ${res.status} when subscribing to address updates`);
-                }
-                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;
-                        const data = JSON.parse(line);
-                        if ("result" in data) {
-                            yield {
-                                txid: data.result.txid,
-                                scripts: data.result.scripts || [],
-                                newVtxos: (data.result.newVtxos || []).map(convertVtxo),
-                                spentVtxos: (data.result.spentVtxos || []).map(convertVtxo),
-                                tx: data.result.tx,
-                                checkpointTxs: data.result.checkpointTxs,
-                            };
+                const eventSource = new EventSource(url);
+                // Set up abort handling
+                const abortHandler = () => {
+                    eventSource.close();
+                };
+                abortSignal?.addEventListener("abort", abortHandler);
+                try {
+                    for await (const event of eventSourceIterator(eventSource)) {
+                        if (abortSignal?.aborted)
+                            break;
+                        try {
+                            const data = JSON.parse(event.data);
+                            if (data.event) {
+                                yield {
+                                    txid: data.event.txid,
+                                    scripts: data.event.scripts || [],
+                                    newVtxos: (data.event.newVtxos || []).map(convertVtxo),
+                                    spentVtxos: (data.event.spentVtxos || []).map(convertVtxo),
+                                    tx: data.event.tx,
+                                    checkpointTxs: data.event.checkpointTxs,
+                                };
+                            }
+                        }
+                        catch (err) {
+                            console.error("Failed to parse subscription event:", err);
+                            throw err;
                         }
                     }
-                    buffer = lines[lines.length - 1];
+                }
+                finally {
+                    abortSignal?.removeEventListener("abort", abortHandler);
+                    eventSource.close();
                 }
             }
             catch (error) {
@@ -199,7 +194,6 @@ export class RestIndexerProvider {
                     break;
                 }
                 // ignore timeout errors, they're expected when the server is not sending anything for 5 min
-                // these timeouts are set by builtin fetch function
                 if (isFetchTimeoutError(error)) {
                     console.debug("Timeout error ignored");
                     continue;
@@ -210,7 +204,7 @@ export class RestIndexerProvider {
         }
     }
     async getVirtualTxs(txids, opts) {
-        let url = `${this.serverUrl}/v1/virtualTx/${txids.join(",")}`;
+        let url = `${this.serverUrl}/v1/indexer/virtualTx/${txids.join(",")}`;
         const params = new URLSearchParams();
         if (opts) {
             if (opts.pageIndex !== undefined)
@@ -232,7 +226,7 @@ export class RestIndexerProvider {
         return data;
     }
     async getVtxoChain(vtxoOutpoint, opts) {
-        let url = `${this.serverUrl}/v1/vtxo/${vtxoOutpoint.txid}/${vtxoOutpoint.vout}/chain`;
+        let url = `${this.serverUrl}/v1/indexer/vtxo/${vtxoOutpoint.txid}/${vtxoOutpoint.vout}/chain`;
         const params = new URLSearchParams();
         if (opts) {
             if (opts.pageIndex !== undefined)
@@ -261,7 +255,7 @@ export class RestIndexerProvider {
         if (!opts?.scripts && !opts?.outpoints) {
             throw new Error("Either scripts or outpoints must be provided");
         }
-        let url = `${this.serverUrl}/v1/vtxos`;
+        let url = `${this.serverUrl}/v1/indexer/vtxos`;
         const params = new URLSearchParams();
         // Handle scripts with multi collection format
         if (opts?.scripts && opts.scripts.length > 0) {
@@ -304,7 +298,7 @@ export class RestIndexerProvider {
         };
     }
     async subscribeForScripts(scripts, subscriptionId) {
-        const url = `${this.serverUrl}/v1/script/subscribe`;
+        const url = `${this.serverUrl}/v1/indexer/script/subscribe`;
         const res = await fetch(url, {
             headers: {
                 "Content-Type": "application/json",
@@ -322,7 +316,7 @@ export class RestIndexerProvider {
         return data.subscriptionId;
     }
     async unsubscribeForScripts(subscriptionId, scripts) {
-        const url = `${this.serverUrl}/v1/script/unsubscribe`;
+        const url = `${this.serverUrl}/v1/indexer/script/unsubscribe`;
         const res = await fetch(url, {
             headers: {
                 "Content-Type": "application/json",
@@ -438,7 +432,7 @@ var Response;
         return (typeof data === "object" &&
             isOutpoint(data.outpoint) &&
             typeof data.createdAt === "string" &&
-            typeof data.expiresAt === "string" &&
+            (data.expiresAt === null || typeof data.expiresAt === "string") &&
             typeof data.amount === "string" &&
             typeof data.script === "string" &&
             typeof data.isPreconfirmed === "boolean" &&

package/dist/esm/providers/utils.js

@@ -0,0 +1,57 @@
+export async function* eventSourceIterator(eventSource) {
+    const messageQueue = [];
+    const errorQueue = [];
+    let messageResolve = null;
+    let errorResolve = null;
+    const messageHandler = (event) => {
+        if (messageResolve) {
+            messageResolve(event);
+            messageResolve = null;
+        }
+        else {
+            messageQueue.push(event);
+        }
+    };
+    const errorHandler = () => {
+        const error = new Error("EventSource error");
+        if (errorResolve) {
+            errorResolve(error);
+            errorResolve = null;
+        }
+        else {
+            errorQueue.push(error);
+        }
+    };
+    eventSource.addEventListener("message", messageHandler);
+    eventSource.addEventListener("error", errorHandler);
+    try {
+        while (true) {
+            // if we have queued messages, yield the first one, remove it from the queue
+            if (messageQueue.length > 0) {
+                yield messageQueue.shift();
+                continue;
+            }
+            // if we have queued errors, throw the first one, remove it from the queue
+            if (errorQueue.length > 0) {
+                const error = errorQueue.shift();
+                throw error;
+            }
+            // wait for the next message or error
+            const result = await new Promise((resolve, reject) => {
+                messageResolve = resolve;
+                errorResolve = reject;
+            }).finally(() => {
+                messageResolve = null;
+                errorResolve = null;
+            });
+            if (result) {
+                yield result;
+            }
+        }
+    }
+    finally {
+        // clean up
+        eventSource.removeEventListener("message", messageHandler);
+        eventSource.removeEventListener("error", errorHandler);
+    }
+}

package/dist/esm/repositories/walletRepository.js

@@ -1,3 +1,32 @@
+import { hex } from "@scure/base";
+import { TaprootControlBlock } from "@scure/btc-signer";
+// Utility functions for (de)serializing complex structures
+const toHex = (b) => (b ? hex.encode(b) : undefined);
+const fromHex = (h) => h ? hex.decode(h) : undefined;
+const serializeTapLeaf = ([cb, s]) => ({
+    cb: TaprootControlBlock.encode(cb) &&
+        hex.encode(TaprootControlBlock.encode(cb)),
+    s: hex.encode(s),
+});
+const serializeVtxo = (v) => ({
+    ...v,
+    tapTree: toHex(v.tapTree),
+    forfeitTapLeafScript: serializeTapLeaf(v.forfeitTapLeafScript),
+    intentTapLeafScript: serializeTapLeaf(v.intentTapLeafScript),
+    extraWitness: v.extraWitness?.map((w) => toHex(w)),
+});
+const deserializeTapLeaf = (t) => {
+    const cb = TaprootControlBlock.decode(fromHex(t.cb));
+    const s = fromHex(t.s);
+    return [cb, s];
+};
+const deserializeVtxo = (o) => ({
+    ...o,
+    tapTree: fromHex(o.tapTree),
+    forfeitTapLeafScript: deserializeTapLeaf(o.forfeitTapLeafScript),
+    intentTapLeafScript: deserializeTapLeaf(o.intentTapLeafScript),
+    extraWitness: o.extraWitness?.map((w) => fromHex(w)),
+});
 export class WalletRepositoryImpl {
     constructor(storage) {
         this.storage = storage;
@@ -19,7 +48,8 @@ export class WalletRepositoryImpl {
             return [];
         }
         try {
-            const vtxos = JSON.parse(stored);
+            const parsed = JSON.parse(stored);
+            const vtxos = parsed.map(deserializeVtxo);
             this.cache.vtxos.set(address, vtxos);
             return vtxos.slice();
         }
@@ -39,7 +69,7 @@ export class WalletRepositoryImpl {
             vtxos.push(vtxo);
         }
         this.cache.vtxos.set(address, vtxos);
-        await this.storage.setItem(`vtxos:${address}`, JSON.stringify(vtxos));
+        await this.storage.setItem(`vtxos:${address}`, JSON.stringify(vtxos.map(serializeVtxo)));
     }
     async saveVtxos(address, vtxos) {
         const storedVtxos = await this.getVtxos(address);
@@ -53,14 +83,14 @@ export class WalletRepositoryImpl {
             }
         }
         this.cache.vtxos.set(address, storedVtxos);
-        await this.storage.setItem(`vtxos:${address}`, JSON.stringify(storedVtxos));
+        await this.storage.setItem(`vtxos:${address}`, JSON.stringify(storedVtxos.map(serializeVtxo)));
     }
     async removeVtxo(address, vtxoId) {
         const vtxos = await this.getVtxos(address);
         const [txid, vout] = vtxoId.split(":");
         const filtered = vtxos.filter((v) => !(v.txid === txid && v.vout === parseInt(vout)));
         this.cache.vtxos.set(address, filtered);
-        await this.storage.setItem(`vtxos:${address}`, JSON.stringify(filtered));
+        await this.storage.setItem(`vtxos:${address}`, JSON.stringify(filtered.map(serializeVtxo)));
     }
     async clearVtxos(address) {
         this.cache.vtxos.set(address, []);

package/dist/esm/script/tapscript.js

@@ -260,7 +260,7 @@ export var CSVMultisigTapscript;
             throw new Error(`Invalid script: too short (expected at least 3)`);
         }
         const sequence = asm[0];
-        if (typeof sequence === "string" || typeof sequence === "number") {
+        if (typeof sequence === "string") {
             throw new Error("Invalid script: expected sequence number");
         }
         if (asm[1] !== "CHECKSEQUENCEVERIFY" || asm[2] !== "DROP") {
@@ -274,7 +274,13 @@ export var CSVMultisigTapscript;
         catch (error) {
             throw new Error(`Invalid multisig script: ${error instanceof Error ? error.message : String(error)}`);
         }
-        const sequenceNum = Number(MinimalScriptNum.decode(sequence));
+        let sequenceNum;
+        if (typeof sequence === "number") {
+            sequenceNum = sequence;
+        }
+        else {
+            sequenceNum = Number(MinimalScriptNum.decode(sequence));
+        }
         const decodedTimelock = bip68.decode(sequenceNum);
         const timelock = decodedTimelock.blocks !== undefined
             ? { type: "blocks", value: BigInt(decodedTimelock.blocks) }

package/dist/esm/tree/signingSession.js

@@ -53,7 +53,7 @@ export class TreeSignerSession {
         if (!this.myNonces)
             throw new Error("nonces not generated");
         const sigs = new Map();
-        for (const g of this.graph) {
+        for (const g of this.graph.iterator()) {
             const sig = this.signPartial(g);
             sigs.set(g.txid, sig);
         }
@@ -64,7 +64,7 @@ export class TreeSignerSession {
             throw ErrMissingVtxoGraph;
         const myNonces = new Map();
         const publicKey = secp256k1.getPublicKey(this.secretKey);
-        for (const g of this.graph) {
+        for (const g of this.graph.iterator()) {
             const nonces = musig2.generateNonces(publicKey);
             myNonces.set(g.txid, nonces);
         }
@@ -106,7 +106,7 @@ TreeSignerSession.NOT_INITIALIZED = new Error("session not initialized, call ini
 // Helper function to validate tree signatures
 export async function validateTreeSigs(finalAggregatedKey, sharedOutputAmount, vtxoTree) {
     // Iterate through each level of the tree
-    for (const g of vtxoTree) {
+    for (const g of vtxoTree.iterator()) {
         // Parse the transaction
         const input = g.root.getInput(0);
         // Check if input has signature

package/dist/esm/tree/txTree.js

@@ -154,11 +154,11 @@ export class TxTree {
         }
         throw new Error(`tx not found: ${txid}`);
     }
-    *[Symbol.iterator]() {
-        yield this;
+    *iterator() {
         for (const child of this.children.values()) {
-            yield* child;
+            yield* child.iterator();
         }
+        yield this;
     }
 }
 // Helper function to check if a chunk has a specific child

package/dist/esm/tree/validation.js

@@ -75,7 +75,7 @@ export function validateVtxoTxGraph(graph, roundTransaction, sweepTapTreeRoot) {
     // validate the graph structure
     graph.validate();
     // iterates over all the nodes of the graph to verify that cosigners public keys are corresponding to the parent output
-    for (const g of graph) {
+    for (const g of graph.iterator()) {
         for (const [childIndex, child] of g.children) {
             const parentOutput = g.root.getOutput(childIndex);
             if (!parentOutput?.script) {

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

@@ -14,7 +14,7 @@ export async function setupServiceWorker(path) {
     // register service worker
     const registration = await navigator.serviceWorker.register(path);
     // force update to ensure the service worker is active
-    registration.update();
+    await registration.update();
     const serviceWorker = registration.active || registration.waiting || registration.installing;
     if (!serviceWorker) {
         throw new Error("Failed to get service worker instance");
@@ -36,11 +36,11 @@ export async function setupServiceWorker(path) {
             reject(new Error("Service worker activation timed out"));
         }, 10000);
         const cleanup = () => {
-            serviceWorker.removeEventListener("activate", onActivate);
-            serviceWorker.removeEventListener("error", onError);
+            navigator.serviceWorker.removeEventListener("activate", onActivate);
+            navigator.serviceWorker.removeEventListener("error", onError);
             clearTimeout(timeout);
         };
-        serviceWorker.addEventListener("activate", onActivate);
-        serviceWorker.addEventListener("error", onError);
+        navigator.serviceWorker.addEventListener("activate", onActivate);
+        navigator.serviceWorker.addEventListener("error", onError);
     });
 }