@arkade-os/sdk 0.4.20 → 0.4.22

package/dist/cjs/wallet/wallet.js

@@ -39,10 +39,28 @@ const contractManager_1 = require("../contracts/contractManager");
 const handlers_1 = require("../contracts/handlers");
 const helpers_1 = require("../contracts/handlers/helpers");
 const syncCursors_1 = require("../utils/syncCursors");
-// Hardcoded unilateral exit delay for mainnet (~7 days in seconds).
-// Pinned here so that address derivation stays stable for existing mainnet
-// wallets even after the server lowers the delay it advertises.
+// Historical unilateral exit delay for mainnet (~7 days in seconds).
+// Kept so existing wallets can still discover and spend VTXOs sent to the
+// legacy address after arkd starts advertising a different delay.
 const MAINNET_UNILATERAL_EXIT_DELAY = 605184n;
+function delayToTimelock(delay) {
+    return {
+        value: delay,
+        type: delay < 512n ? "blocks" : "seconds",
+    };
+}
+function dedupeTimelocks(timelocks) {
+    const seen = new Set();
+    const deduped = [];
+    for (const timelock of timelocks) {
+        const sequence = (0, helpers_1.timelockToSequence)(timelock).toString();
+        if (seen.has(sequence))
+            continue;
+        seen.add(sequence);
+        deduped.push(timelock);
+    }
+    return deduped;
+}
 /**
  * Type guard function to check if an identity has a toReadonly method.
  */
@@ -56,7 +74,7 @@ class ReadonlyWallet {
     get assetManager() {
         return this._assetManager;
     }
-    constructor(identity, network, onchainProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, dustAmount, walletRepository, contractRepository, delegatorProvider, watcherConfig) {
+    constructor(identity, network, onchainProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, dustAmount, walletRepository, contractRepository, delegatorProvider, watcherConfig, walletContractTimelocks) {
         this.identity = identity;
         this.network = network;
         this.onchainProvider = onchainProvider;
@@ -89,6 +107,15 @@ class ReadonlyWallet {
         }
         this.watcherConfig = watcherConfig;
         this._assetManager = new asset_manager_1.ReadonlyAssetManager(this.indexerProvider);
+        // Defensive for direct-construction callers; setupWalletConfig already
+        // passes a deduped list through the public create() factories.
+        this.walletContractTimelocks =
+            walletContractTimelocks && walletContractTimelocks.length > 0
+                ? dedupeTimelocks(walletContractTimelocks)
+                : [
+                    this.offchainTapscript.options.csvTimelock ??
+                        default_1.DefaultVtxo.Script.DEFAULT_TIMELOCK,
+                ];
     }
     /**
      * Protected helper to set up shared wallet configuration.
@@ -144,17 +171,17 @@ class ReadonlyWallet {
                 throw new Error("invalid exitTimelock");
             }
         }
-        // On mainnet, pin the unilateral exit delay to the historical value so
-        // that addresses derived by existing wallets remain stable even if the
-        // server starts advertising a shorter delay.
-        const unilateralExitDelay = info.network === "bitcoin"
-            ? MAINNET_UNILATERAL_EXIT_DELAY
-            : info.unilateralExitDelay;
+        const arkdExitTimelock = delayToTimelock(info.unilateralExitDelay);
         // create unilateral exit timelock
-        const exitTimelock = config.exitTimelock ?? {
-            value: unilateralExitDelay,
-            type: unilateralExitDelay < 512n ? "blocks" : "seconds",
-        };
+        const exitTimelock = config.exitTimelock ?? arkdExitTimelock;
+        const walletContractTimelocks = config.exitTimelock
+            ? [exitTimelock]
+            : dedupeTimelocks([
+                arkdExitTimelock,
+                ...(info.network === "bitcoin"
+                    ? [delayToTimelock(MAINNET_UNILATERAL_EXIT_DELAY)]
+                    : []),
+            ]);
         // validate boarding timelock passed in config if any
         if (config.boardingTimelock) {
             const { value, type } = config.boardingTimelock;
@@ -204,6 +231,7 @@ class ReadonlyWallet {
             contractRepository,
             info,
             delegatorProvider: config.delegatorProvider,
+            walletContractTimelocks,
         };
     }
     /**
@@ -218,14 +246,14 @@ class ReadonlyWallet {
             throw new Error("Invalid configured public key");
         }
         const setup = await ReadonlyWallet.setupWalletConfig(config, pubkey);
-        return new ReadonlyWallet(config.identity, setup.network, setup.onchainProvider, setup.indexerProvider, setup.serverPubKey, setup.offchainTapscript, setup.boardingTapscript, setup.dustAmount, setup.walletRepository, setup.contractRepository, setup.delegatorProvider, config.watcherConfig);
+        return new ReadonlyWallet(config.identity, setup.network, setup.onchainProvider, setup.indexerProvider, setup.serverPubKey, setup.offchainTapscript, setup.boardingTapscript, setup.dustAmount, setup.walletRepository, setup.contractRepository, setup.delegatorProvider, config.watcherConfig, setup.walletContractTimelocks);
     }
     get arkAddress() {
         return this.offchainTapscript.address(this.network.hrp, this.arkServerPublicKey);
     }
     /**
-     * Get the contract script for the wallet's default address.
-     * This is the pkScript hex, used to identify the wallet in ContractManager.
+     * Get the pkScript hex for the wallet's primary offchain address.
+     * For the full wallet-owned script set registered in ContractManager, use getWalletScripts().
      */
     get defaultContractScript() {
         return base_1.hex.encode(this.offchainTapscript.pkScript);
@@ -469,56 +497,39 @@ class ReadonlyWallet {
             });
         }
         if (this.indexerProvider && arkAddress) {
-            const walletScripts = await this.getWalletScripts();
-            const subscriptionId = await this.indexerProvider.subscribeForScripts(walletScripts);
-            const abortController = new AbortController();
-            const subscription = this.indexerProvider.getSubscription(subscriptionId, abortController.signal);
-            indexerStopFunc = async () => {
-                abortController.abort();
-                await this.indexerProvider?.unsubscribeForScripts(subscriptionId);
-            };
-            // Handle subscription updates asynchronously without blocking.
-            // Subscription covers all wallet scripts (default + delegate) plus
-            // any additional registered contracts. Virtual outputs carry a
-            // `script` field from the indexer which the contract manager
-            // resolves to the owning contract so the extension uses the
-            // correct forfeit/intent tapscripts.
-            (async () => {
-                try {
-                    const cm = await this.getContractManager();
-                    for await (const update of subscription) {
-                        if (update.newVtxos?.length === 0 &&
-                            update.spentVtxos?.length === 0) {
-                            continue;
-                        }
-                        // Isolate per-update annotation failures (e.g. a VTXO
-                        // arriving for a contract we haven't registered yet).
-                        // Without this a single bad update would kill the
-                        // for-await loop and silently drop every subsequent
-                        // subscription event for the session.
-                        try {
-                            // Default to `[]` so a one-sided update (e.g.
-                            // only `newVtxos`) doesn't pass `undefined` into
-                            // annotateVtxos and throw on `.length`.
-                            const [newVtxos, spentVtxos] = await Promise.all([
-                                cm.annotateVtxos(update.newVtxos ?? []),
-                                cm.annotateVtxos(update.spentVtxos ?? []),
-                            ]);
-                            eventCallback({
-                                type: "vtxo",
-                                newVtxos,
-                                spentVtxos,
-                            });
-                        }
-                        catch (error) {
-                            console.warn("Dropping subscription update after annotation failed; next sync will reconcile:", error);
-                        }
-                    }
+            // Share the ContractWatcher's single subscription instead of
+            // opening a second SSE stream.
+            const cm = await this.getContractManager();
+            // Serialize annotation+notification: parallel `annotateVtxos`
+            // awaits could resolve out of order and deliver eventCallback
+            // calls in the wrong sequence (e.g. `vtxo_spent` before its
+            // matching `vtxo_received`).
+            let annotationQueue = Promise.resolve();
+            indexerStopFunc = cm.onContractEvent((event) => {
+                if (event.type !== "vtxo_received" &&
+                    event.type !== "vtxo_spent") {
+                    return;
                 }
-                catch (error) {
-                    console.error("Subscription error:", error);
+                if (event.contract.type !== "default" &&
+                    event.contract.type !== "delegate") {
+                    return;
                 }
-            })();
+                // `event.vtxos` carries placeholder tapscript fields from
+                // the watcher; `annotateVtxos` fills them in.
+                annotationQueue = annotationQueue.then(async () => {
+                    try {
+                        const annotated = await cm.annotateVtxos(event.vtxos);
+                        eventCallback({
+                            type: "vtxo",
+                            newVtxos: event.type === "vtxo_received" ? annotated : [],
+                            spentVtxos: event.type === "vtxo_spent" ? annotated : [],
+                        });
+                    }
+                    catch (error) {
+                        console.warn("Dropping subscription update after annotation failed; next sync will reconcile:", error);
+                    }
+                });
+            });
         }
         const stopFunc = () => {
             onchainStopFunc?.();
@@ -545,27 +556,13 @@ class ReadonlyWallet {
     /**
      * Get all pkScript hex strings for the wallet's own addresses
      * (both delegate and non-delegate, current and historical).
-     * Falls back to only the current script if ContractManager is not yet initialized.
      */
     async getWalletScripts() {
-        // Only use the contract manager if it's already initialized or
-        // currently initializing — never trigger initialization here to
-        // avoid blocking callers that don't need it.
-        if (this._contractManager || this._contractManagerInitializing) {
-            try {
-                const manager = await this.getContractManager();
-                const contracts = await manager.getContracts({
-                    type: ["default", "delegate"],
-                });
-                if (contracts.length > 0) {
-                    return contracts.map((c) => c.script);
-                }
-            }
-            catch {
-                // fall through to current script only
-            }
-        }
-        return [base_1.hex.encode(this.offchainTapscript.pkScript)];
+        const manager = await this.getContractManager();
+        const contracts = await manager.getContracts({
+            type: ["default", "delegate"],
+        });
+        return contracts.map((c) => c.script);
     }
     /**
      * Build a map of scriptHex → VtxoScript for all wallet contracts,
@@ -573,26 +570,17 @@ class ReadonlyWallet {
      */
     async getScriptMap() {
         const map = new Map();
-        // Always include the current script
-        const currentScriptHex = base_1.hex.encode(this.offchainTapscript.pkScript);
-        map.set(currentScriptHex, this.offchainTapscript);
-        if (this._contractManager) {
-            try {
-                const contracts = await this._contractManager.getContracts({
-                    type: ["default", "delegate"],
-                });
-                for (const contract of contracts) {
-                    if (map.has(contract.script))
-                        continue;
-                    const handler = handlers_1.contractHandlers.get(contract.type);
-                    if (handler) {
-                        const script = handler.createScript(contract.params);
-                        map.set(contract.script, script);
-                    }
-                }
-            }
-            catch {
-                // ContractManager error — only current script in map
+        const manager = await this.getContractManager();
+        const contracts = await manager.getContracts({
+            type: ["default", "delegate"],
+        });
+        for (const contract of contracts) {
+            if (map.has(contract.script))
+                continue;
+            const handler = handlers_1.contractHandlers.get(contract.type);
+            if (handler) {
+                const script = handler.createScript(contract.params);
+                map.set(contract.script, script);
             }
         }
         return map;
@@ -660,62 +648,48 @@ class ReadonlyWallet {
             walletRepository: this.walletRepository,
             watcherConfig: this.watcherConfig,
         });
-        // Register the wallet's current address as a contract
-        const csvTimelock = this.offchainTapscript.options.csvTimelock ??
-            default_1.DefaultVtxo.Script.DEFAULT_TIMELOCK;
-        const csvTimelockStr = (0, helpers_1.timelockToSequence)(csvTimelock).toString();
-        const isDelegateScript = this.offchainTapscript instanceof delegate_1.DelegateVtxo.Script;
-        if (isDelegateScript) {
-            const delegateScript = this
-                .offchainTapscript;
-            // Register the delegate contract (current address)
-            await manager.createContract({
-                type: "delegate",
-                params: {
-                    pubKey: base_1.hex.encode(delegateScript.options.pubKey),
-                    serverPubKey: base_1.hex.encode(delegateScript.options.serverPubKey),
-                    delegatePubKey: base_1.hex.encode(delegateScript.options.delegatePubKey),
-                    csvTimelock: csvTimelockStr,
-                },
-                script: this.defaultContractScript,
-                address: await this.getAddress(),
-                state: "active",
-            });
-            // Also register the non-delegate version so old virtual outputs remain visible
-            const nonDelegateScript = new default_1.DefaultVtxo.Script({
-                pubKey: delegateScript.options.pubKey,
-                serverPubKey: delegateScript.options.serverPubKey,
+        for (const csvTimelock of this.walletContractTimelocks) {
+            const csvTimelockStr = (0, helpers_1.timelockToSequence)(csvTimelock).toString();
+            const defaultScript = new default_1.DefaultVtxo.Script({
+                pubKey: this.offchainTapscript.options.pubKey,
+                serverPubKey: this.offchainTapscript.options.serverPubKey,
                 csvTimelock,
             });
             await manager.createContract({
                 type: "default",
                 params: {
-                    pubKey: base_1.hex.encode(delegateScript.options.pubKey),
-                    serverPubKey: base_1.hex.encode(delegateScript.options.serverPubKey),
+                    pubKey: base_1.hex.encode(defaultScript.options.pubKey),
+                    serverPubKey: base_1.hex.encode(defaultScript.options.serverPubKey),
                     csvTimelock: csvTimelockStr,
                 },
-                script: base_1.hex.encode(nonDelegateScript.pkScript),
-                address: nonDelegateScript
+                script: base_1.hex.encode(defaultScript.pkScript),
+                address: defaultScript
                     .address(this.network.hrp, this.arkServerPublicKey)
                     .encode(),
                 state: "active",
             });
-        }
-        else {
-            // Register the default contract (current address)
-            await manager.createContract({
-                type: "default",
-                params: {
-                    pubKey: base_1.hex.encode(this.offchainTapscript.options.pubKey),
-                    serverPubKey: base_1.hex.encode(this.offchainTapscript.options.serverPubKey),
-                    csvTimelock: csvTimelockStr,
-                },
-                script: this.defaultContractScript,
-                address: await this.getAddress(),
-                state: "active",
-            });
-            // Any old "delegate" contract from a prior wallet incarnation
-            // is already loaded by ContractManager.initialize() from ContractRepository
+            if (this.offchainTapscript instanceof delegate_1.DelegateVtxo.Script) {
+                const delegateScript = new delegate_1.DelegateVtxo.Script({
+                    pubKey: this.offchainTapscript.options.pubKey,
+                    serverPubKey: this.offchainTapscript.options.serverPubKey,
+                    delegatePubKey: this.offchainTapscript.options.delegatePubKey,
+                    csvTimelock,
+                });
+                await manager.createContract({
+                    type: "delegate",
+                    params: {
+                        pubKey: base_1.hex.encode(delegateScript.options.pubKey),
+                        serverPubKey: base_1.hex.encode(delegateScript.options.serverPubKey),
+                        delegatePubKey: base_1.hex.encode(delegateScript.options.delegatePubKey),
+                        csvTimelock: csvTimelockStr,
+                    },
+                    script: base_1.hex.encode(delegateScript.pkScript),
+                    address: delegateScript
+                        .address(this.network.hrp, this.arkServerPublicKey)
+                        .encode(),
+                    state: "active",
+                });
+            }
         }
         return manager;
     }
@@ -799,8 +773,8 @@ class Wallet extends ReadonlyWallet {
     }
     constructor(identity, network, onchainProvider, arkProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, dustAmount, walletRepository, contractRepository, 
     /** @deprecated Use settlementConfig */
-    renewalConfig, delegatorProvider, watcherConfig, settlementConfig) {
-        super(identity, network, onchainProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, dustAmount, walletRepository, contractRepository, delegatorProvider, watcherConfig);
+    renewalConfig, delegatorProvider, watcherConfig, settlementConfig, walletContractTimelocks) {
+        super(identity, network, onchainProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, dustAmount, walletRepository, contractRepository, delegatorProvider, watcherConfig, walletContractTimelocks);
         this.arkProvider = arkProvider;
         this.serverUnrollScript = serverUnrollScript;
         this.forfeitOutputScript = forfeitOutputScript;
@@ -920,7 +894,7 @@ class Wallet extends ReadonlyWallet {
         const forfeitPubkey = base_1.hex.decode(setup.info.forfeitPubkey).slice(1);
         const forfeitAddress = (0, btc_signer_1.Address)(setup.network).decode(setup.info.forfeitAddress);
         const forfeitOutputScript = btc_signer_1.OutScript.encode(forfeitAddress);
-        const wallet = new Wallet(config.identity, setup.network, setup.onchainProvider, setup.arkProvider, setup.indexerProvider, setup.serverPubKey, setup.offchainTapscript, setup.boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, setup.dustAmount, setup.walletRepository, setup.contractRepository, config.renewalConfig, config.delegatorProvider, config.watcherConfig, config.settlementConfig);
+        const wallet = new Wallet(config.identity, setup.network, setup.onchainProvider, setup.arkProvider, setup.indexerProvider, setup.serverPubKey, setup.offchainTapscript, setup.boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, setup.dustAmount, setup.walletRepository, setup.contractRepository, config.renewalConfig, config.delegatorProvider, config.watcherConfig, config.settlementConfig, setup.walletContractTimelocks);
         await wallet.getVtxoManager();
         return wallet;
     }
@@ -946,7 +920,7 @@ class Wallet extends ReadonlyWallet {
         const readonlyIdentity = hasToReadonly(this.identity)
             ? await this.identity.toReadonly()
             : this.identity; // Identity extends ReadonlyIdentity, so this is safe
-        return new ReadonlyWallet(readonlyIdentity, this.network, this.onchainProvider, this.indexerProvider, this.arkServerPublicKey, this.offchainTapscript, this.boardingTapscript, this.dustAmount, this.walletRepository, this.contractRepository, this.delegatorProvider, this.watcherConfig);
+        return new ReadonlyWallet(readonlyIdentity, this.network, this.onchainProvider, this.indexerProvider, this.arkServerPublicKey, this.offchainTapscript, this.boardingTapscript, this.dustAmount, this.walletRepository, this.contractRepository, this.delegatorProvider, this.watcherConfig, this.walletContractTimelocks);
     }
     /** Returns the delegator manager when delegation support is configured. */
     async getDelegatorManager() {

package/dist/esm/contracts/contractWatcher.js

@@ -1,3 +1,4 @@
+import { extendVirtualCoinForContract } from '../wallet/utils.js';
 import { isEventSourceError } from '../providers/utils.js';
 /**
  * Watches multiple contracts for virtual output state changes with resilient connection handling.
@@ -251,13 +252,18 @@ export 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";
@@ -388,11 +394,30 @@ export 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);
+            });
         }
     }
     /**
@@ -526,18 +551,22 @@ export class ContractWatcher {
         const state = this.contracts.get(contractScript);
         if (!state)
             return;
+        const extended = [];
+        for (const v of vtxos) {
+            try {
+                const extendedVtxo = 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,
@@ -546,14 +575,7 @@ export 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/esm/providers/ark.js

@@ -232,18 +232,19 @@ export 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 = eventSourceIterator(eventSource);
+                    const currentIterator = 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 {
@@ -277,71 +278,87 @@ export 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 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 = 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 (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 (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`;