@arkade-os/sdk 0.4.20 → 0.4.22

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;
     /**

package/dist/types/contracts/types.d.ts

@@ -1,6 +1,6 @@
 import { Bytes } from "@scure/btc-signer/utils.js";
-import { TapLeafScript, VtxoScript } from "../script/base";
-import { VirtualCoin, ExtendedVirtualCoin } from "../wallet";
+import { EncodedVtxoScript, TapLeafScript, VtxoScript } from "../script/base";
+import { VirtualCoin, TapLeaves } from "../wallet";
 import { ContractFilter } from "../repositories";
 /**
  * Contract state indicating whether it should be actively monitored.
@@ -66,10 +66,10 @@ export interface Contract {
 /**
  * A virtual output that has been associated with a specific contract.
  */
-export interface ContractVtxo extends ExtendedVirtualCoin {
-    /** The contract script this virtual output belongs to. */
+export type ContractVtxo = VirtualCoin & Partial<TapLeaves & EncodedVtxoScript> & {
+    extraWitness?: Bytes[];
     contractScript: string;
-}
+};
 /**
  * Result of path selection, including the tapleaf to use and any extra witness data.
  */

package/dist/types/providers/utils.d.ts

@@ -1,8 +1,12 @@
+export type ManagedEventSourceIterator = AsyncGenerator<MessageEvent, void, unknown> & {
+    close(): void;
+};
 /**
- * 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 declare function eventSourceIterator(eventSource: EventSource): AsyncGenerator<MessageEvent, void, unknown>;
+export declare function eventSourceIterator(eventSource: EventSource): ManagedEventSourceIterator;
 export declare function isEventSourceError(error: unknown): error is Error;

package/dist/types/wallet/delegator.d.ts

@@ -1,17 +1,22 @@
 import { TransactionOutput } from "@scure/btc-signer/psbt";
-import { ArkProvider, DelegateInfo, ExtendedVirtualCoin, Identity, Outpoint } from "..";
+import { ArkProvider, DelegateInfo, Identity, Outpoint } from "..";
+import { ContractVtxo } from "../contracts/types";
 import { DelegatorProvider } from "../providers/delegator";
 import { Bytes } from "@scure/btc-signer/utils";
 export interface IDelegatorManager {
     /**
      * Delegate virtual outputs to the remote delegation service.
      *
+     * Vtxos that are not locked to a delegate-type contract (no tap leaf
+     * matches the delegator's pubkey) are filtered out silently, since they
+     * cannot be co-signed by the delegator.
+     *
      * @param vtxos - Virtual outputs to delegate
      * @param destination - Arkade address that should receive renewed funds
      * @param delegateAt - Optional timestamp to force a specific delegation time
      * @returns Successfully delegated and failed outpoint groups
      */
-    delegate(vtxos: ExtendedVirtualCoin[], destination: string, delegateAt?: Date): Promise<{
+    delegate(vtxos: ContractVtxo[], destination: string, delegateAt?: Date): Promise<{
         delegated: Outpoint[];
         failed: {
             outpoints: Outpoint[];
@@ -28,7 +33,7 @@ export declare class DelegatorManagerImpl implements IDelegatorManager {
     /** Create a delegator manager from the configured provider, Arkade info source, and wallet identity. */
     constructor(delegatorProvider: DelegatorProvider, arkInfoProvider: Pick<ArkProvider, "getInfo">, identity: Identity);
     getDelegateInfo(): Promise<DelegateInfo>;
-    delegate(vtxos: ExtendedVirtualCoin[], destination: string, delegateAt?: Date): Promise<{
+    delegate(vtxos: ContractVtxo[], destination: string, delegateAt?: Date): Promise<{
         delegated: Outpoint[];
         failed: {
             outpoints: Outpoint[];

package/dist/types/wallet/wallet.d.ts

@@ -8,7 +8,7 @@ import { ArkProvider, SettlementEvent, SignedIntent } from "../providers/ark";
 import { SignerSession } from "../tree/signingSession";
 import { Identity, ReadonlyIdentity } from "../identity";
 import { ArkTransaction, Coin, ExtendedCoin, ExtendedVirtualCoin, GetVtxosFilter, IAssetManager, IReadonlyAssetManager, IReadonlyWallet, IWallet, ReadonlyWalletConfig, Recipient, SendBitcoinParams, SettleParams, WalletBalance, WalletConfig } from ".";
-import { CSVMultisigTapscript } from "../script/tapscript";
+import { CSVMultisigTapscript, RelativeTimelock } from "../script/tapscript";
 import { SettlementConfig, VtxoManager } from "./vtxo-manager";
 import { Intent } from "../intent";
 import { IndexerProvider } from "../providers/indexer";
@@ -44,9 +44,10 @@ export declare class ReadonlyWallet implements IReadonlyWallet {
     protected readonly watcherConfig?: ReadonlyWalletConfig["watcherConfig"];
     private readonly _assetManager;
     private _syncVtxosInflight?;
+    readonly walletContractTimelocks: RelativeTimelock[];
     protected _pendingSpendOutpoints: Set<string>;
     get assetManager(): IReadonlyAssetManager;
-    protected constructor(identity: ReadonlyIdentity, network: Network, onchainProvider: OnchainProvider, indexerProvider: IndexerProvider, arkServerPublicKey: Bytes, offchainTapscript: DefaultVtxo.Script | DelegateVtxo.Script, boardingTapscript: DefaultVtxo.Script, dustAmount: bigint, walletRepository: WalletRepository, contractRepository: ContractRepository, delegatorProvider?: DelegatorProvider | undefined, watcherConfig?: ReadonlyWalletConfig["watcherConfig"]);
+    protected constructor(identity: ReadonlyIdentity, network: Network, onchainProvider: OnchainProvider, indexerProvider: IndexerProvider, arkServerPublicKey: Bytes, offchainTapscript: DefaultVtxo.Script | DelegateVtxo.Script, boardingTapscript: DefaultVtxo.Script, dustAmount: bigint, walletRepository: WalletRepository, contractRepository: ContractRepository, delegatorProvider?: DelegatorProvider | undefined, watcherConfig?: ReadonlyWalletConfig["watcherConfig"], walletContractTimelocks?: RelativeTimelock[]);
     /**
      * Protected helper to set up shared wallet configuration.
      * Extracts common logic used by both ReadonlyWallet.create() and Wallet.create().
@@ -65,6 +66,7 @@ export declare class ReadonlyWallet implements IReadonlyWallet {
         contractRepository: ContractRepository;
         info: import("../providers/ark").ArkInfo;
         delegatorProvider: DelegatorProvider | undefined;
+        walletContractTimelocks: RelativeTimelock[];
     }>;
     /**
      * Create a readonly wallet for querying balances, addresses, and history.
@@ -75,8 +77,8 @@ export declare class ReadonlyWallet implements IReadonlyWallet {
     static create(config: ReadonlyWalletConfig): Promise<ReadonlyWallet>;
     get arkAddress(): ArkAddress;
     /**
-     * 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(): string;
     /** Returns the wallet's Arkade address. */
@@ -125,7 +127,6 @@ export declare class ReadonlyWallet implements IReadonlyWallet {
     /**
      * 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.
      */
     getWalletScripts(): Promise<string[]>;
     /**
@@ -229,7 +230,7 @@ export declare class Wallet extends ReadonlyWallet implements IWallet {
     readonly settlementConfig: SettlementConfig | false;
     protected constructor(identity: Identity, network: Network, onchainProvider: OnchainProvider, arkProvider: ArkProvider, indexerProvider: IndexerProvider, arkServerPublicKey: Bytes, offchainTapscript: DefaultVtxo.Script | DelegateVtxo.Script, boardingTapscript: DefaultVtxo.Script, serverUnrollScript: CSVMultisigTapscript.Type, forfeitOutputScript: Bytes, forfeitPubkey: Bytes, dustAmount: bigint, walletRepository: WalletRepository, contractRepository: ContractRepository, 
     /** @deprecated Use settlementConfig */
-    renewalConfig?: WalletConfig["renewalConfig"], delegatorProvider?: DelegatorProvider, watcherConfig?: WalletConfig["watcherConfig"], settlementConfig?: WalletConfig["settlementConfig"]);
+    renewalConfig?: WalletConfig["renewalConfig"], delegatorProvider?: DelegatorProvider, watcherConfig?: WalletConfig["watcherConfig"], settlementConfig?: WalletConfig["settlementConfig"], walletContractTimelocks?: RelativeTimelock[]);
     get assetManager(): IAssetManager;
     getVtxoManager(): Promise<VtxoManager>;
     dispose(): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkade-os/sdk",
-  "version": "0.4.20",
+  "version": "0.4.22",
   "description": "TypeScript SDK for building Bitcoin wallets using the Arkade protocol",
   "type": "module",
   "main": "./dist/cjs/index.js",
@@ -109,9 +109,9 @@
   "peerDependencies": {
     "@react-native-async-storage/async-storage": ">=1.0.0",
     "expo": ">=54.0.0",
-    "expo-background-task": "~1.0.10",
-    "expo-sqlite": "~16.0.10",
-    "expo-task-manager": "~14.0.9"
+    "expo-background-task": "~1.0.10 || >=55.0.0",
+    "expo-sqlite": "~16.0.10 || >=55.0.0",
+    "expo-task-manager": "~14.0.9 || >=55.0.0"
   },
   "peerDependenciesMeta": {
     "expo": {