@arkade-os/sdk 0.4.19 → 0.4.21

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

@@ -5,6 +5,8 @@ import { hex } from "@scure/base";
 import { getSequence } from '../script/base.js';
 import { Transaction } from '../utils/transaction.js';
 import { TxWeightEstimator } from '../utils/txSizeEstimator.js';
+import { Estimator } from '../arkfee/index.js';
+import { ArkAddress } from '../script/address.js';
 /**
  * Return whether a wallet exposes the properties required for boarding input sweep operations.
  *
@@ -14,6 +16,7 @@ import { TxWeightEstimator } from '../utils/txSizeEstimator.js';
 function isSweepCapable(wallet) {
     return ("boardingTapscript" in wallet &&
         "onchainProvider" in wallet &&
+        "arkProvider" in wallet &&
         "network" in wallet);
 }
 /**
@@ -24,7 +27,7 @@ function isSweepCapable(wallet) {
  */
 function assertSweepCapable(wallet) {
     if (!isSweepCapable(wallet)) {
-        throw new Error("Boarding UTXO sweep requires a Wallet instance with boardingTapscript, onchainProvider, and network");
+        throw new Error("Boarding UTXO sweep requires a Wallet instance with boardingTapscript, onchainProvider, arkProvider, and network");
     }
 }
 /**
@@ -622,6 +625,10 @@ export class VtxoManager {
     getOnchainProvider() {
         return this.getSweepWallet().onchainProvider;
     }
+    /** Returns the Ark provider for intent fee and server info lookups. */
+    getArkProvider() {
+        return this.getSweepWallet().arkProvider;
+    }
     /** Returns the Bitcoin network configuration from the wallet. */
     getNetwork() {
         return this.getSweepWallet().network;
@@ -891,13 +898,54 @@ export class VtxoManager {
             return;
         }
         const dustAmount = getDustAmount(this.wallet);
-        const boardingTotal = unsettledBoarding.reduce((sum, u) => sum + BigInt(u.value), 0n);
-        const vtxoTotal = expiringVtxos.reduce((sum, v) => sum + BigInt(v.value), 0n);
-        const totalAmount = boardingTotal + vtxoTotal;
-        if (totalAmount < dustAmount)
+        // Fetch server intent-fee config so each input/output can be priced.
+        // Without this, settle sends `outputAmount = sum(inputs)` and the
+        // server rejects with INTENT_INSUFFICIENT_FEE whenever the operator
+        // charges non-zero intent fees.
+        const { fees } = await this.getArkProvider().getInfo();
+        const estimator = new Estimator(fees.intentFee);
+        let totalAmount = 0n;
+        const filteredBoarding = [];
+        for (const u of unsettledBoarding) {
+            const inputFee = estimator.evalOnchainInput({
+                amount: BigInt(u.value),
+            });
+            if (inputFee.value >= BigInt(u.value)) {
+                // Fee exceeds input value — including it would drain the output.
+                continue;
+            }
+            filteredBoarding.push(u);
+            totalAmount += BigInt(u.value) - BigInt(inputFee.satoshis);
+        }
+        const filteredVtxos = [];
+        for (const v of expiringVtxos) {
+            const inputFee = estimator.evalOffchainInput({
+                amount: BigInt(v.value),
+                type: v.virtualStatus.state === "swept" ? "recoverable" : "vtxo",
+                weight: 0,
+                birth: v.createdAt,
+                expiry: v.virtualStatus.batchExpiry
+                    ? new Date(v.virtualStatus.batchExpiry)
+                    : undefined,
+            });
+            if (inputFee.satoshis >= v.value) {
+                continue;
+            }
+            filteredVtxos.push(v);
+            totalAmount += BigInt(v.value) - BigInt(inputFee.satoshis);
+        }
+        if (filteredBoarding.length === 0 && filteredVtxos.length === 0) {
             return;
+        }
         const arkAddress = await this.wallet.getAddress();
-        const includesVtxos = expiringVtxos.length > 0;
+        const outputFee = estimator.evalOffchainOutput({
+            amount: totalAmount,
+            script: hex.encode(ArkAddress.decode(arkAddress).pkScript),
+        });
+        totalAmount -= BigInt(outputFee.satoshis);
+        if (totalAmount < dustAmount)
+            return;
+        const includesVtxos = filteredVtxos.length > 0;
         // Block the event-driven renewal path while this settle is in flight
         // when VTXOs are part of the intent. Mirrors renewVtxos()'s guard so
         // the two paths can't race on the same VTXO inputs.
@@ -909,11 +957,11 @@ export class VtxoManager {
         try {
             try {
                 await this.wallet.settle({
-                    inputs: [...unsettledBoarding, ...expiringVtxos],
+                    inputs: [...filteredBoarding, ...filteredVtxos],
                     outputs: [{ address: arkAddress, amount: totalAmount }],
                 });
                 // Mark boarding inputs as known only after successful settle.
-                for (const u of unsettledBoarding) {
+                for (const u of filteredBoarding) {
                     this.knownBoardingUtxos.add(`${u.txid}:${u.vout}`);
                 }
                 success = true;

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() {
@@ -1071,10 +1045,10 @@ export class Wallet extends ReadonlyWallet {
                     weight: 0,
                     birth: vtxo.createdAt,
                     expiry: vtxo.virtualStatus.batchExpiry
-                        ? new Date(vtxo.virtualStatus.batchExpiry * 1000)
-                        : new Date(),
+                        ? new Date(vtxo.virtualStatus.batchExpiry)
+                        : undefined,
                 });
-                if (inputFee.value >= vtxo.value) {
+                if (inputFee.satoshis >= vtxo.value) {
                     // skip if fees are greater than the virtual output value
                     continue;
                 }