@arkade-os/sdk 0.4.20 → 0.4.21

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/wallet.js

@@ -34,10 +34,28 @@ import { ContractManager } from '../contracts/contractManager.js';
 import { contractHandlers } from '../contracts/handlers/index.js';
 import { timelockToSequence } from '../contracts/handlers/helpers.js';
 import { clearSyncCursor, updateWalletState } from '../utils/syncCursors.js';
-// 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 = 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.
  */
@@ -51,7 +69,7 @@ export 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;
@@ -84,6 +102,15 @@ export class ReadonlyWallet {
         }
         this.watcherConfig = watcherConfig;
         this._assetManager = new 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 ??
+                        DefaultVtxo.Script.DEFAULT_TIMELOCK,
+                ];
     }
     /**
      * Protected helper to set up shared wallet configuration.
@@ -139,17 +166,17 @@ export 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;
@@ -199,6 +226,7 @@ export class ReadonlyWallet {
             contractRepository,
             info,
             delegatorProvider: config.delegatorProvider,
+            walletContractTimelocks,
         };
     }
     /**
@@ -213,14 +241,14 @@ export 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 hex.encode(this.offchainTapscript.pkScript);
@@ -464,56 +492,39 @@ export 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?.();
@@ -540,27 +551,13 @@ export 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 [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,
@@ -568,26 +565,17 @@ export class ReadonlyWallet {
      */
     async getScriptMap() {
         const map = new Map();
-        // Always include the current script
-        const currentScriptHex = 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 = 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 = contractHandlers.get(contract.type);
+            if (handler) {
+                const script = handler.createScript(contract.params);
+                map.set(contract.script, script);
             }
         }
         return map;
@@ -655,62 +643,48 @@ export class ReadonlyWallet {
             walletRepository: this.walletRepository,
             watcherConfig: this.watcherConfig,
         });
-        // Register the wallet's current address as a contract
-        const csvTimelock = this.offchainTapscript.options.csvTimelock ??
-            DefaultVtxo.Script.DEFAULT_TIMELOCK;
-        const csvTimelockStr = timelockToSequence(csvTimelock).toString();
-        const isDelegateScript = this.offchainTapscript instanceof DelegateVtxo.Script;
-        if (isDelegateScript) {
-            const delegateScript = this
-                .offchainTapscript;
-            // Register the delegate contract (current address)
-            await manager.createContract({
-                type: "delegate",
-                params: {
-                    pubKey: hex.encode(delegateScript.options.pubKey),
-                    serverPubKey: hex.encode(delegateScript.options.serverPubKey),
-                    delegatePubKey: 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 DefaultVtxo.Script({
-                pubKey: delegateScript.options.pubKey,
-                serverPubKey: delegateScript.options.serverPubKey,
+        for (const csvTimelock of this.walletContractTimelocks) {
+            const csvTimelockStr = timelockToSequence(csvTimelock).toString();
+            const defaultScript = new DefaultVtxo.Script({
+                pubKey: this.offchainTapscript.options.pubKey,
+                serverPubKey: this.offchainTapscript.options.serverPubKey,
                 csvTimelock,
             });
             await manager.createContract({
                 type: "default",
                 params: {
-                    pubKey: hex.encode(delegateScript.options.pubKey),
-                    serverPubKey: hex.encode(delegateScript.options.serverPubKey),
+                    pubKey: hex.encode(defaultScript.options.pubKey),
+                    serverPubKey: hex.encode(defaultScript.options.serverPubKey),
                     csvTimelock: csvTimelockStr,
                 },
-                script: hex.encode(nonDelegateScript.pkScript),
-                address: nonDelegateScript
+                script: 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: hex.encode(this.offchainTapscript.options.pubKey),
-                    serverPubKey: 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 DelegateVtxo.Script) {
+                const delegateScript = new 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: hex.encode(delegateScript.options.pubKey),
+                        serverPubKey: hex.encode(delegateScript.options.serverPubKey),
+                        delegatePubKey: hex.encode(delegateScript.options.delegatePubKey),
+                        csvTimelock: csvTimelockStr,
+                    },
+                    script: hex.encode(delegateScript.pkScript),
+                    address: delegateScript
+                        .address(this.network.hrp, this.arkServerPublicKey)
+                        .encode(),
+                    state: "active",
+                });
+            }
         }
         return manager;
     }
@@ -793,8 +767,8 @@ export 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;
@@ -914,7 +888,7 @@ export class Wallet extends ReadonlyWallet {
         const forfeitPubkey = hex.decode(setup.info.forfeitPubkey).slice(1);
         const forfeitAddress = Address(setup.network).decode(setup.info.forfeitAddress);
         const forfeitOutputScript = 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;
     }
@@ -940,7 +914,7 @@ export 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/types/contracts/contractWatcher.d.ts

@@ -168,6 +168,9 @@ export declare class ContractWatcher {
     forcePoll(): Promise<void>;
     /**
      * Connect to the subscription.
+     *
+     * @param skipUpdate - Skip the leading `updateSubscription` call when
+     *   the caller has already established `subscriptionId`.
      */
     private connect;
     /**