@arkade-os/sdk 0.4.20 → 0.4.22

package/dist/cjs/contracts/contractWatcher.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContractWatcher = void 0;
-const utils_1 = require("../providers/utils");
+const utils_1 = require("../wallet/utils");
+const utils_2 = require("../providers/utils");
 /**
  * Watches multiple contracts for virtual output state changes with resilient connection handling.
  *
@@ -254,13 +255,18 @@ class ContractWatcher {
     }
     /**
      * Connect to the subscription.
+     *
+     * @param skipUpdate - Skip the leading `updateSubscription` call when
+     *   the caller has already established `subscriptionId`.
      */
-    async connect() {
+    async connect(skipUpdate = false) {
         if (!this.isWatching)
             return;
         this.connectionState = "connecting";
         try {
-            await this.updateSubscription();
+            if (!skipUpdate) {
+                await this.updateSubscription();
+            }
             // Poll immediately after connection to sync state
             await this.pollAllContracts();
             this.connectionState = "connected";
@@ -271,7 +277,7 @@ class ContractWatcher {
                 // indefinitely and block the caller.
                 // Error management must be implemented to ensure the connection
                 // is restored and events are fired.
-                if ((0, utils_1.isEventSourceError)(e)) {
+                if ((0, utils_2.isEventSourceError)(e)) {
                     console.debug("ContractWatcher subscription disconnected; reconnecting");
                 }
                 else {
@@ -391,11 +397,30 @@ class ContractWatcher {
         }
     }
     async tryUpdateSubscription() {
+        const hadSubscription = this.subscriptionId !== undefined;
         try {
             await this.updateSubscription();
         }
         catch (error) {
             // nothing, the connection will be retried later
+            return;
+        }
+        // Cold start: `startWatching` may have run with zero scripts,
+        // leaving `listenLoop` parked behind the reconnect timer. Kick
+        // `connect` now so streaming resumes without waiting on the
+        // backoff. `skipUpdate` avoids re-issuing `subscribeForScripts`.
+        const justGotSubscription = !hadSubscription && this.subscriptionId !== undefined;
+        const listenerParked = this.connectionState === "disconnected" ||
+            this.connectionState === "reconnecting";
+        if (this.isWatching && justGotSubscription && listenerParked) {
+            if (this.reconnectTimeoutId) {
+                clearTimeout(this.reconnectTimeoutId);
+                this.reconnectTimeoutId = undefined;
+            }
+            this.reconnectAttempts = 0;
+            this.connect(true).catch((error) => {
+                console.warn("ContractWatcher cold-start connect failed:", error);
+            });
         }
     }
     /**
@@ -529,18 +554,22 @@ class ContractWatcher {
         const state = this.contracts.get(contractScript);
         if (!state)
             return;
+        const extended = [];
+        for (const v of vtxos) {
+            try {
+                const extendedVtxo = (0, utils_1.extendVirtualCoinForContract)(v, state.contract);
+                extended.push({ ...extendedVtxo, contractScript });
+            }
+            catch {
+                console.warn("failed to extend vtxo: ", v);
+                extended.push({ ...v, contractScript });
+            }
+        }
         switch (eventType) {
             case "vtxo_received":
                 this.eventCallback({
                     type: "vtxo_received",
-                    vtxos: vtxos.map((v) => ({
-                        ...v,
-                        contractScript,
-                        // These fields may not be available from basic VirtualCoin
-                        forfeitTapLeafScript: undefined,
-                        intentTapLeafScript: undefined,
-                        tapTree: undefined,
-                    })),
+                    vtxos: extended,
                     contractScript,
                     contract: state.contract,
                     timestamp,
@@ -549,14 +578,7 @@ class ContractWatcher {
             case "vtxo_spent":
                 this.eventCallback({
                     type: "vtxo_spent",
-                    vtxos: vtxos.map((v) => ({
-                        ...v,
-                        contractScript,
-                        // These fields may not be available from basic VirtualCoin
-                        forfeitTapLeafScript: undefined,
-                        intentTapLeafScript: undefined,
-                        tapTree: undefined,
-                    })),
+                    vtxos: extended,
                     contractScript,
                     contract: state.contract,
                     timestamp,

package/dist/cjs/providers/ark.js

@@ -236,18 +236,19 @@ class RestArkProvider {
         // leak the underlying SSE connection. `return()` is overridden below
         // so that closing the generator also closes the connection even when
         // the body is currently suspended at an await point.
-        let eventSource = null;
+        let iterator = null;
+        const closeIterator = () => iterator?.close();
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         const self = this;
         const gen = (async function* () {
-            const abortHandler = () => eventSource?.close();
+            const abortHandler = closeIterator;
             signal?.addEventListener("abort", abortHandler);
             try {
                 while (!signal?.aborted) {
-                    eventSource = new EventSource(url + queryParams);
-                    const iterator = (0, utils_1.eventSourceIterator)(eventSource);
+                    const currentIterator = (0, utils_1.eventSourceIterator)(new EventSource(url + queryParams));
+                    iterator = currentIterator;
                     try {
-                        for await (const event of iterator) {
+                        for await (const event of currentIterator) {
                             if (signal?.aborted)
                                 break;
                             try {
@@ -281,71 +282,87 @@ class RestArkProvider {
                         throw error;
                     }
                     finally {
-                        eventSource.close();
+                        currentIterator.close();
+                        iterator = null;
                     }
                 }
             }
             finally {
                 signal?.removeEventListener("abort", abortHandler);
-                eventSource?.close();
+                closeIterator();
             }
         })();
         const origReturn = gen.return.bind(gen);
         gen.return = (value) => {
-            eventSource?.close();
+            closeIterator();
             return origReturn(value);
         };
         return gen;
     }
-    async *getTransactionsStream(signal) {
+    getTransactionsStream(signal) {
         const url = `${this.serverUrl}/v1/txs`;
-        while (!signal?.aborted) {
+        let iterator = null;
+        const closeIterator = () => iterator?.close();
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        const gen = (async function* () {
+            const abortHandler = closeIterator;
+            signal?.addEventListener("abort", abortHandler);
             try {
-                const eventSource = new EventSource(url);
-                // Set up abort handling
-                const abortHandler = () => {
-                    eventSource.close();
-                };
-                signal?.addEventListener("abort", abortHandler);
-                try {
-                    for await (const event of (0, utils_1.eventSourceIterator)(eventSource)) {
-                        if (signal?.aborted)
-                            break;
-                        try {
-                            const data = JSON.parse(event.data);
-                            const txNotification = this.parseTransactionNotification(data);
-                            if (txNotification) {
-                                yield txNotification;
+                while (!signal?.aborted) {
+                    try {
+                        const currentIterator = (0, utils_1.eventSourceIterator)(new EventSource(url));
+                        iterator = currentIterator;
+                        for await (const event of currentIterator) {
+                            if (signal?.aborted)
+                                break;
+                            try {
+                                const data = JSON.parse(event.data);
+                                const txNotification = self.parseTransactionNotification(data);
+                                if (txNotification) {
+                                    yield txNotification;
+                                }
+                            }
+                            catch (err) {
+                                console.error("Failed to parse transaction notification:", err);
+                                throw err;
                             }
                         }
-                        catch (err) {
-                            console.error("Failed to parse transaction notification:", err);
-                            throw err;
+                    }
+                    catch (error) {
+                        if (signal?.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 ((0, utils_1.isEventSourceError)(error)) {
+                            throw error;
+                        }
+                        console.error("Transaction stream error:", error);
+                        throw error;
+                    }
+                    finally {
+                        closeIterator();
+                        iterator = null;
                     }
-                }
-                finally {
-                    signal?.removeEventListener("abort", abortHandler);
-                    eventSource.close();
                 }
             }
-            catch (error) {
-                if (signal?.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 ((0, utils_1.isEventSourceError)(error)) {
-                    throw error;
-                }
-                console.error("Transaction stream error:", error);
-                throw error;
+            finally {
+                signal?.removeEventListener("abort", abortHandler);
+                closeIterator();
             }
-        }
+        })();
+        const origReturn = gen.return.bind(gen);
+        gen.return = (value) => {
+            closeIterator();
+            return origReturn(value);
+        };
+        return gen;
     }
     async getPendingTxs(intent) {
         const url = `${this.serverUrl}/v1/tx/pending`;

package/dist/cjs/providers/indexer.js

@@ -156,62 +156,75 @@ 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 (0, utils_1.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 = (0, utils_1.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 ((0, ark_1.isFetchTimeoutError)(error)) {
+                            console.debug("Timeout error ignored");
+                            continue;
+                        }
+                        if ((0, utils_1.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 ((0, ark_1.isFetchTimeoutError)(error)) {
-                    console.debug("Timeout error ignored");
-                    continue;
-                }
-                if ((0, utils_1.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/cjs/providers/utils.js

@@ -2,32 +2,70 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.eventSourceIterator = eventSourceIterator;
 exports.isEventSourceError = isEventSourceError;
+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().
  */
 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);
@@ -37,9 +75,9 @@ 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();
@@ -58,17 +96,25 @@ 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;
 }
 function isEventSourceError(error) {
     return error instanceof Error && error.name === "EventSourceError";

package/dist/cjs/wallet/delegator.js

@@ -29,20 +29,30 @@ 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 ((0, __1.isRecoverable)(vtxo)) {
                 recoverableVtxos.push(vtxo);
                 continue;
@@ -190,20 +200,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 = __1.VtxoScript.decode(input.tapTree);
-    const delegateTapLeaf = vtxoScript.leaves.find((tapLeaf) => {
-        const arkTapscript = (0, __1.decodeTapscript)((0, base_2.scriptFromTapLeafScript)(tapLeaf));
-        if (!__1.MultisigTapscript.is(arkTapscript))
-            return false;
-        if (!arkTapscript.params.pubkeys
-            .map(base_1.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}`);
     }
@@ -291,3 +288,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 = __1.VtxoScript.decode(vtxo.tapTree);
+    return vtxoScript.leaves.find((tapLeaf) => {
+        const arkTapscript = (0, __1.decodeTapscript)((0, base_2.scriptFromTapLeafScript)(tapLeaf));
+        if (!__1.MultisigTapscript.is(arkTapscript))
+            return false;
+        return arkTapscript.params.pubkeys.map(base_1.hex.encode).includes(pk);
+    });
+}

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

@@ -706,7 +706,9 @@ 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/cjs/wallet/vtxo-manager.js

@@ -698,11 +698,13 @@ 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;
         }