@arkade-os/sdk 0.4.20 → 0.4.22

package/dist/esm/providers/indexer.js

@@ -153,62 +153,75 @@ export class RestIndexerProvider {
         }
         return data;
     }
-    async *getSubscription(subscriptionId, abortSignal) {
+    getSubscription(subscriptionId, abortSignal) {
         const url = `${this.serverUrl}/v1/indexer/script/subscription/${subscriptionId}`;
-        while (!abortSignal?.aborted) {
+        let iterator = null;
+        const closeIterator = () => iterator?.close();
+        const gen = (async function* () {
+            const abortHandler = closeIterator;
+            abortSignal?.addEventListener("abort", abortHandler);
             try {
-                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),
-                                    sweptVtxos: (data.event.sweptVtxos || []).map(convertVtxo),
-                                    tx: data.event.tx,
-                                    checkpointTxs: data.event.checkpointTxs,
-                                };
+                while (!abortSignal?.aborted) {
+                    try {
+                        const currentIterator = eventSourceIterator(new EventSource(url));
+                        iterator = currentIterator;
+                        for await (const event of currentIterator) {
+                            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),
+                                        sweptVtxos: (data.event.sweptVtxos || []).map(convertVtxo),
+                                        tx: data.event.tx,
+                                        checkpointTxs: data.event.checkpointTxs,
+                                    };
+                                }
+                            }
+                            catch (err) {
+                                console.error("Failed to parse subscription event:", err);
+                                throw err;
                             }
                         }
-                        catch (err) {
-                            console.error("Failed to parse subscription event:", err);
-                            throw err;
+                    }
+                    catch (error) {
+                        if (abortSignal?.aborted ||
+                            (error instanceof Error &&
+                                error.name === "AbortError")) {
+                            break;
                         }
+                        // ignore timeout errors, they're expected when the server is not sending anything for 5 min
+                        if (isFetchTimeoutError(error)) {
+                            console.debug("Timeout error ignored");
+                            continue;
+                        }
+                        if (isEventSourceError(error)) {
+                            throw error;
+                        }
+                        console.error("Subscription error:", error);
+                        throw error;
+                    }
+                    finally {
+                        closeIterator();
+                        iterator = null;
                     }
-                }
-                finally {
-                    abortSignal?.removeEventListener("abort", abortHandler);
-                    eventSource.close();
                 }
             }
-            catch (error) {
-                if (abortSignal?.aborted ||
-                    (error instanceof Error && error.name === "AbortError")) {
-                    break;
-                }
-                // ignore timeout errors, they're expected when the server is not sending anything for 5 min
-                if (isFetchTimeoutError(error)) {
-                    console.debug("Timeout error ignored");
-                    continue;
-                }
-                if (isEventSourceError(error)) {
-                    throw error;
-                }
-                console.error("Subscription error:", error);
-                throw error;
+            finally {
+                abortSignal?.removeEventListener("abort", abortHandler);
+                closeIterator();
             }
-        }
+        })();
+        const origReturn = gen.return.bind(gen);
+        gen.return = (value) => {
+            closeIterator();
+            return origReturn(value);
+        };
+        return gen;
     }
     async getVirtualTxs(txids, opts) {
         let url = `${this.serverUrl}/v1/indexer/virtualTx/${txids.join(",")}`;

package/dist/esm/providers/utils.js

@@ -1,29 +1,67 @@
+function createAbortError() {
+    const error = new Error("EventSource closed");
+    error.name = "AbortError";
+    return error;
+}
 /**
- * Creates an async iterator over EventSource messages that attaches listeners
- * eagerly (at call time) rather than lazily (at first .next() call).
- * This ensures events are buffered immediately, preventing race conditions
- * where events arrive before iteration begins.
+ * Creates a close-aware EventSource async iterator.
+ *
+ * Listeners attach eagerly so events are buffered before the first next() call.
+ * close() closes the EventSource, removes listeners, and wakes any pending
+ * next() even when the browser does not emit an error from EventSource.close().
  */
 export function eventSourceIterator(eventSource) {
     const messageQueue = [];
     const errorQueue = [];
     let messageResolve = null;
     let errorResolve = null;
+    let closed = false;
+    let cleanedUp = false;
+    const cleanup = () => {
+        if (cleanedUp)
+            return;
+        cleanedUp = true;
+        eventSource.removeEventListener("message", messageHandler);
+        eventSource.removeEventListener("error", errorHandler);
+    };
+    const close = () => {
+        if (closed)
+            return;
+        closed = true;
+        messageQueue.length = 0;
+        errorQueue.length = 0;
+        eventSource.close();
+        cleanup();
+        if (errorResolve) {
+            const reject = errorResolve;
+            messageResolve = null;
+            errorResolve = null;
+            reject(createAbortError());
+        }
+    };
     const messageHandler = (event) => {
+        if (closed)
+            return;
         if (messageResolve) {
-            messageResolve(event);
+            const resolve = messageResolve;
             messageResolve = null;
+            errorResolve = null;
+            resolve(event);
         }
         else {
             messageQueue.push(event);
         }
     };
     const errorHandler = () => {
+        if (closed)
+            return;
         const error = new Error("EventSource error");
         error.name = "EventSourceError";
         if (errorResolve) {
-            errorResolve(error);
+            const reject = errorResolve;
+            messageResolve = null;
             errorResolve = null;
+            reject(error);
         }
         else {
             errorQueue.push(error);
@@ -33,9 +71,9 @@ export function eventSourceIterator(eventSource) {
     // even before the caller starts iterating
     eventSource.addEventListener("message", messageHandler);
     eventSource.addEventListener("error", errorHandler);
-    return (async function* () {
+    const gen = (async function* () {
         try {
-            while (true) {
+            while (!closed) {
                 // if we have queued messages, yield the first one, remove it from the queue
                 if (messageQueue.length > 0) {
                     yield messageQueue.shift();
@@ -54,17 +92,25 @@ export function eventSourceIterator(eventSource) {
                     messageResolve = null;
                     errorResolve = null;
                 });
-                if (result) {
+                if (!closed && result) {
                     yield result;
                 }
             }
         }
         finally {
-            // clean up
-            eventSource.removeEventListener("message", messageHandler);
-            eventSource.removeEventListener("error", errorHandler);
+            closed = true;
+            cleanup();
+            eventSource.close();
         }
     })();
+    const origReturn = gen.return.bind(gen);
+    const managed = gen;
+    managed.close = close;
+    managed.return = (value) => {
+        close();
+        return origReturn(value);
+    };
+    return managed;
 }
 export function isEventSourceError(error) {
     return error instanceof Error && error.name === "EventSourceError";

package/dist/esm/wallet/delegator.js

@@ -25,20 +25,30 @@ export class DelegatorManagerImpl {
         // fetch server and delegator info once, shared across all groups
         const arkInfo = await this.arkInfoProvider.getInfo();
         const delegateInfo = await this.delegatorProvider.getDelegateInfo();
+        // keep only vtxos that can be signed by the delegate
+        const eligible = vtxos
+            .filter((v) => findDelegateTapLeaf(v, delegateInfo.pubkey) !== undefined)
+            .map((v) => v);
+        if (eligible.length === 0) {
+            return { delegated: [], failed: [] };
+        }
         // if explicit delegateAt is provided, delegate all virtual outputs at once without sorting
         if (delegateAt) {
             try {
-                await delegate(this.identity, this.delegatorProvider, arkInfo, delegateInfo, vtxos, destinationScript, delegateAt);
+                await delegate(this.identity, this.delegatorProvider, arkInfo, delegateInfo, eligible, destinationScript, delegateAt);
             }
             catch (error) {
-                return { delegated: [], failed: [{ outpoints: vtxos, error }] };
+                return {
+                    delegated: [],
+                    failed: [{ outpoints: eligible, error }],
+                };
             }
-            return { delegated: vtxos, failed: [] };
+            return { delegated: eligible, failed: [] };
         }
         // if no explicit delegateAt is provided, sort virtual outputs by expiry and delegate in groups of the same expiry day
         const groupByExpiry = new Map();
         let recoverableVtxos = [];
-        for (const vtxo of vtxos) {
+        for (const vtxo of eligible) {
             if (isRecoverable(vtxo)) {
                 recoverableVtxos.push(vtxo);
                 continue;
@@ -185,20 +195,7 @@ async function delegate(identity, delegatorProvider, arkInfo, delegateInfo, vtxo
     await delegatorProvider.delegate(registerIntent, forfeits);
 }
 async function makeDelegateForfeitTx(input, connectorAmount, delegatePubkey, forfeitOutputScript, identity) {
-    if (delegatePubkey.length === 66) {
-        delegatePubkey = delegatePubkey.slice(2);
-    }
-    const vtxoScript = VtxoScript.decode(input.tapTree);
-    const delegateTapLeaf = vtxoScript.leaves.find((tapLeaf) => {
-        const arkTapscript = decodeTapscript(scriptFromTapLeafScript(tapLeaf));
-        if (!MultisigTapscript.is(arkTapscript))
-            return false;
-        if (!arkTapscript.params.pubkeys
-            .map(hex.encode)
-            .includes(delegatePubkey))
-            return false;
-        return true;
-    });
+    const delegateTapLeaf = findDelegateTapLeaf(input, delegatePubkey);
     if (!delegateTapLeaf) {
         throw new Error(`delegate tap leaf not found for input: ${input.txid}:${input.vout}`);
     }
@@ -286,3 +283,15 @@ function getDayTimestamp(timestamp) {
     date.setUTCHours(0, 0, 0, 0);
     return date.getTime();
 }
+function findDelegateTapLeaf(vtxo, delegatePubkey) {
+    if (!vtxo.tapTree)
+        return undefined;
+    const pk = delegatePubkey.length === 66 ? delegatePubkey.slice(2) : delegatePubkey;
+    const vtxoScript = VtxoScript.decode(vtxo.tapTree);
+    return vtxoScript.leaves.find((tapLeaf) => {
+        const arkTapscript = decodeTapscript(scriptFromTapLeafScript(tapLeaf));
+        if (!MultisigTapscript.is(arkTapscript))
+            return false;
+        return arkTapscript.params.pubkeys.map(hex.encode).includes(pk);
+    });
+}

package/dist/esm/wallet/serviceWorker/wallet-message-handler.js

@@ -700,7 +700,9 @@ export class WalletMessageHandler {
         const { vtxoOutpoints, destination, delegateAt } = message.payload;
         const allVtxos = await wallet.getVtxos();
         const outpointSet = new Set(vtxoOutpoints.map((o) => `${o.txid}:${o.vout}`));
-        const filtered = allVtxos.filter((v) => outpointSet.has(`${v.txid}:${v.vout}`));
+        const filtered = allVtxos
+            .filter((v) => outpointSet.has(`${v.txid}:${v.vout}`))
+            .map((v) => ({ ...v, contractScript: v.script }));
         const result = await delegatorManager.delegate(filtered, destination, delegateAt !== undefined ? new Date(delegateAt) : undefined);
         return {
             tag: this.messageTag,

package/dist/esm/wallet/vtxo-manager.js

@@ -693,11 +693,13 @@ export class VtxoManager {
                         console.error("Error renewing VTXOs:", e);
                     });
                 }
-                delegatorManager
-                    ?.delegate(event.vtxos, destination)
-                    .catch((e) => {
-                    console.error("Error delegating VTXOs:", e);
-                });
+                if (delegatorManager) {
+                    delegatorManager
+                        .delegate(event.vtxos, destination)
+                        .catch((e) => {
+                        console.error("Error delegating VTXOs:", e);
+                    });
+                }
             });
             return stopWatching;
         }