@arkade-os/sdk 0.4.56 → 0.4.58

package/dist/{chunk-T22257HW.js → chunk-S3BFUTC5.js}

@@ -1,6 +1,6 @@
-import { AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, Packet, BufferReader, BufferWriter, AssetRef, RestIndexerProvider } from './chunk-NN7BNNF5.js';
-import { witnessRefToBytes, validateProgram, toASM, stringifyArtifact, serializeArkadeContractParams, resolveAsm, parseArtifact, getOpcodeValue, getOpcodeName, fromASM, deserializeArkadeContractParams, computeArkadeScriptPublicKey, bytesToASM, asmToBytes, arkadeWitnessHash, arkadeScriptHash, SUPPORTED_PROGRAM_VERSION, OPCODE_VALUES, OPCODE_NAMES, bignum_exports, ArkadeScript, ArkadeProgramScript, ARKADE_OPS, ARKADE_OPCODE_VALUES, ARKADE_OPCODE_NAMES, ARKADE_OPCODES, ARKADE_OP, inputName, contractHandlers, isMainnetDescriptor, descriptorIsOurs, deriveDescriptorLeafPubKey, deriveDescriptorLeafCompressedPubKey, DefaultVtxo, speculativeReceiveMetadata, DelegateVtxo, WALLET_RECEIVE_SOURCE, BoardingContractHandler } from './chunk-OOPDT2WV.js';
-import { VtxoScript, Transaction, isRecoverable, CSVMultisigTapscript, DEFAULT_NETWORK, hasTerminalSpend, getNormalizedVtxos, setArkPsbtField, PrevArkTxField, ConditionWitness, craftToSpendTx, ArkAddress, isVirtualCoin, getArkPsbtFields, CosignerPublicKey, ServerResponseMismatchError, OP_RETURN_EMPTY_PKSCRIPT, sequenceToTimelock, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, VtxoTaprootTree, timelockToSequence, baseFetch, Intent, rateGate, DEFAULT_NETWORK_NAME, normalizeVtxo, getSequence, toBatchExpiry, maybeArkError, isArkError, ArkErrorName, toOffchainInputFeeParams, canRecoverOnchain, getNetwork, MultisigTapscript, isEventSourceError, isRetryableProviderError, getAllNormalizedVtxos, DEFAULT_PAGE_SIZE, RestArkProvider, canSpendOffchain, toVirtualStatus, ArkError, resolveTimeHeight, parseLegacyExpiry, isExpired, DEFAULT_ARKADE_SERVER_URL, ProviderUnavailableError, networks as networks$1, isPastExpiry, fetchVtxoCreatedAtByTxid } from './chunk-IFGN2GB2.js';
+import { AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, Packet, BufferReader, BufferWriter, AssetRef, RestIndexerProvider } from './chunk-TV2RLVOB.js';
+import { witnessRefToBytes, validateProgram, toASM, stringifyArtifact, serializeArkadeContractParams, resolveAsm, parseArtifact, getOpcodeValue, getOpcodeName, fromASM, deserializeArkadeContractParams, computeArkadeScriptPublicKey, bytesToASM, asmToBytes, arkadeWitnessHash, arkadeScriptHash, SUPPORTED_PROGRAM_VERSION, OPCODE_VALUES, OPCODE_NAMES, bignum_exports, ArkadeScript, ArkadeProgramScript, ARKADE_OPS, ARKADE_OPCODE_VALUES, ARKADE_OPCODE_NAMES, ARKADE_OPCODES, ARKADE_OP, inputName, contractHandlers, isMainnetDescriptor, descriptorIsOurs, deriveDescriptorLeafPubKey, deriveDescriptorLeafCompressedPubKey, DefaultVtxo, speculativeReceiveMetadata, DelegateVtxo, WALLET_RECEIVE_SOURCE, BoardingContractHandler } from './chunk-IPPASJE5.js';
+import { VtxoScript, Transaction, isRecoverable, CSVMultisigTapscript, DEFAULT_NETWORK, hasTerminalSpend, getNormalizedVtxos, setArkPsbtField, PrevArkTxField, ConditionWitness, craftToSpendTx, ArkAddress, isVirtualCoin, getArkPsbtFields, CosignerPublicKey, ServerResponseMismatchError, OP_RETURN_EMPTY_PKSCRIPT, sequenceToTimelock, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, VtxoTaprootTree, timelockToSequence, baseFetch, Intent, rateGate, DEFAULT_NETWORK_NAME, normalizeVtxo, getSequence, toBatchExpiry, maybeArkError, isArkError, ArkErrorName, toOffchainInputFeeParams, canRecoverOnchain, getNetwork, MultisigTapscript, isEventSourceError, isRetryableProviderError, getAllNormalizedVtxos, DEFAULT_PAGE_SIZE, RestArkProvider, canSpendOffchain, toVirtualStatus, ArkError, resolveTimeHeight, parseLegacyExpiry, isExpired, DEFAULT_ARKADE_SERVER_URL, ProviderUnavailableError, networks as networks$1, isPastExpiry, fetchVtxoCreatedAtByTxid } from './chunk-VROHHJL4.js';
 import { __export } from './chunk-NSBPE2FW.js';
 import { sha256, equalBytes, hash160, sha256x2, concatBytes, randomPrivateKeyBytes, pubECDSA, pubSchnorr } from '@scure/btc-signer/utils.js';
 import { SigHash, Script, OP, OutScript, Address, RawWitness, p2tr, p2wpkh, TaprootControlBlock, DEFAULT_SEQUENCE, Transaction as Transaction$2 } from '@scure/btc-signer';
@@ -2304,6 +2304,83 @@ function classifyContractSigner(contractServerPubKeyHex, info, nowSeconds = Math
 function isCooperativelyMigratable(status) {
   return status === "MIGRATABLE" || status === "DUE_NOW";
 }
+
+// src/wallet/timelockPolicy.ts
+var isRegtest = (network) => network.bech32 === "bcrt";
+var NOMINAL_BLOCK_SECONDS = 600n;
+var toTimelock = (value) => ({
+  value,
+  type: value >= 512n ? "seconds" : "blocks"
+});
+var toSeconds = (t) => t.type === "seconds" ? t.value : t.value * NOMINAL_BLOCK_SECONDS;
+function assertTimelockInPolicy(timelock, policy, label) {
+  if (policy.requireSeconds && timelock.type === "blocks") {
+    throw new ServerResponseMismatchError(
+      `${label} rejected: block-typed timelocks are not accepted (got ${timelock.value})`
+    );
+  }
+  const seconds = toSeconds(timelock);
+  if (seconds < policy.minSeconds) {
+    throw new ServerResponseMismatchError(
+      `${label} rejected: ${timelock.value} ${timelock.type} is below the ${policy.minSeconds}s floor`
+    );
+  }
+  return timelock;
+}
+function assertTimelockWithinFloor(value, policy, label) {
+  return assertTimelockInPolicy(toTimelock(value), policy, label);
+}
+
+// src/wallet/batchExpiry.ts
+var DEFAULT_MIN_BATCH_EXPIRY_SECONDS = 86400n;
+var REGTEST_MIN_BATCH_EXPIRY_SECONDS = 6000n;
+function defaultBatchExpiryPolicy(network) {
+  return isRegtest(network) ? { minSeconds: REGTEST_MIN_BATCH_EXPIRY_SECONDS, requireSeconds: false } : { minSeconds: DEFAULT_MIN_BATCH_EXPIRY_SECONDS, requireSeconds: true };
+}
+function resolveBatchExpiryPolicy(network, overrides) {
+  return { ...defaultBatchExpiryPolicy(network), ...overrides };
+}
+function assertValidBatchExpiry(batchExpiry, policy) {
+  if (policy.advertisedVtxoTreeExpiry !== void 0 && batchExpiry !== policy.advertisedVtxoTreeExpiry) {
+    throw new ServerResponseMismatchError(
+      `batch expiry rejected: ${batchExpiry} does not match the advertised vtxoTreeExpiry ${policy.advertisedVtxoTreeExpiry}`
+    );
+  }
+  return assertTimelockWithinFloor(batchExpiry, policy, "batch expiry");
+}
+var DEFAULT_MIN_CHECKPOINT_EXIT_DELAY_SECONDS = 86400n;
+var REGTEST_MIN_CHECKPOINT_EXIT_DELAY_SECONDS = 1200n;
+function defaultCheckpointExitDelayPolicy(network) {
+  return isRegtest(network) ? { minSeconds: REGTEST_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, requireSeconds: false } : { minSeconds: DEFAULT_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, requireSeconds: true };
+}
+function resolveCheckpointExitDelayPolicy(network, overrides) {
+  return { ...defaultCheckpointExitDelayPolicy(network), ...overrides };
+}
+function assertValidServerUnrollScript(checkpointTapscript, policy) {
+  let script;
+  try {
+    script = CSVMultisigTapscript.decode(hex.decode(checkpointTapscript));
+  } catch (e) {
+    throw new ServerResponseMismatchError(
+      `checkpoint exit delay rejected: invalid checkpointTapscript from server (${e instanceof Error ? e.message : String(e)})`
+    );
+  }
+  if (policy.advertisedForfeitPubkey !== void 0) {
+    const { pubkeys } = script.params;
+    if (pubkeys.length !== 1) {
+      throw new ServerResponseMismatchError(
+        `checkpoint exit delay rejected: checkpointTapscript must commit to exactly one pubkey, got ${pubkeys.length} [${pubkeys.map(hex.encode).join(", ")}]`
+      );
+    }
+    if (!equalBytes(pubkeys[0], policy.advertisedForfeitPubkey)) {
+      throw new ServerResponseMismatchError(
+        `checkpoint exit delay rejected: checkpointTapscript pubkey ${hex.encode(pubkeys[0])} does not match the advertised forfeitPubkey ${hex.encode(policy.advertisedForfeitPubkey)}`
+      );
+    }
+  }
+  assertTimelockInPolicy(script.params.timelock, policy, "checkpoint exit delay");
+  return script;
+}
 function buildOffchainTx(inputs, outputs, serverUnrollScript) {
   const MAX_OP_RETURN = 2;
   let countOpReturn = 0;
@@ -3020,6 +3097,40 @@ function capSettlementBatch(sorted, maxAmount) {
   }
   return batch;
 }
+function priceSettlementInputs(vtxos, estimator) {
+  const payable = [];
+  const net = /* @__PURE__ */ new Map();
+  for (const vtxo of vtxos) {
+    const inputFee = estimator.evalOffchainInput(toOffchainInputFeeParams(vtxo));
+    if (inputFee.satoshis >= vtxo.value) {
+      continue;
+    }
+    payable.push(vtxo);
+    net.set(`${vtxo.txid}:${vtxo.vout}`, BigInt(vtxo.value - inputFee.satoshis));
+  }
+  return { payable, net };
+}
+function subtotalOf(vtxos, net) {
+  let subtotal = 0n;
+  for (const vtxo of vtxos) {
+    const priced = net.get(`${vtxo.txid}:${vtxo.vout}`);
+    if (priced === void 0) {
+      throw new Error(`Unpriced settlement input ${vtxo.txid}:${vtxo.vout}`);
+    }
+    subtotal += priced;
+  }
+  return subtotal;
+}
+function deductOffchainOutputFee(subtotal, estimator, arkAddress) {
+  if (!estimator.config.offchainOutput) {
+    return subtotal;
+  }
+  const outputFee = estimator.evalOffchainOutput({
+    amount: subtotal,
+    script: hex.encode(ArkAddress.decode(arkAddress).pkScript)
+  });
+  return subtotal - BigInt(outputFee.satoshis);
+}
 var DEFAULT_THRESHOLD_SECONDS = 259200;
 var DEFAULT_THRESHOLD_MS = DEFAULT_THRESHOLD_SECONDS * 1e3;
 var DEFAULT_RENEWAL_CONFIG = {
@@ -3227,19 +3338,27 @@ var VtxoManager = class _VtxoManager {
     });
     const dustAmount = getDustAmount(this.wallet);
     const now = await fetchTimeHeight(this.wallet);
-    let { vtxosToRecover, totalAmount } = getRecoverableWithSubdust(allVtxos, dustAmount, now);
+    let { vtxosToRecover } = getRecoverableWithSubdust(allVtxos, dustAmount, now);
     if (vtxosToRecover.length === 0) {
       throw new Error("No recoverable VTXOs found");
     }
     const info = await this.getInfoProvider()?.getInfo();
     const vtxoMaxAmount = info?.vtxoMaxAmount ?? -1n;
-    const capped = capSettlementBatch(byValueDescending(vtxosToRecover), vtxoMaxAmount);
+    const estimator = new Estimator(info?.fees.intentFee ?? {});
+    const { payable, net } = priceSettlementInputs(vtxosToRecover, estimator);
+    const capped = capSettlementBatch(byValueDescending(payable), vtxoMaxAmount);
     if (capped.length < vtxosToRecover.length) {
       const recoverableCount = vtxosToRecover.length;
-      ({ vtxosToRecover, totalAmount } = getRecoverableWithSubdust(capped, dustAmount, now));
+      const cappedAway = capped.length < payable.length;
+      ({ vtxosToRecover } = getRecoverableWithSubdust(capped, dustAmount, now));
       if (vtxosToRecover.length === 0) {
+        if (!cappedAway) {
+          throw new Error(
+            `All ${recoverableCount} recoverable VTXOs that can pay their own intent fee total less than the dust threshold ${dustAmount}`
+          );
+        }
         throw new Error(
-          `Capped recovery batch (highest-value subset of ${recoverableCount} recoverable VTXOs within the ${MAX_VTXOS_PER_SETTLEMENT}-input and ${vtxoMaxAmount}-sat limits) is below the dust threshold ${dustAmount}`
+          `Capped recovery batch (highest-value subset of ${recoverableCount} recoverable VTXOs within the ${MAX_VTXOS_PER_SETTLEMENT}-input and ${vtxoMaxAmount}-sat limits, net of intent fees) is below the dust threshold ${dustAmount}`
         );
       }
     }
@@ -3247,6 +3366,16 @@ var VtxoManager = class _VtxoManager {
       await this.rotateForRecoverableInputs(vtxosToRecover, info);
     }
     const arkAddress = await this.wallet.getAddress();
+    const totalAmount = deductOffchainOutputFee(
+      subtotalOf(vtxosToRecover, net),
+      estimator,
+      arkAddress
+    );
+    if (totalAmount < dustAmount) {
+      throw new Error(
+        `Recoverable amount ${totalAmount} net of intent fees is below dust threshold ${dustAmount}`
+      );
+    }
     return this.wallet.settle(
       {
         inputs: vtxosToRecover,
@@ -3265,6 +3394,17 @@ var VtxoManager = class _VtxoManager {
    *
    * Useful for displaying to users before they decide to recover funds.
    *
+   * Both amounts are net of the operator's intent fees, so `recoverable` is
+   * what {@link recoverVtxos} would actually hand back rather than the gross
+   * sum of the inputs. `subdust` is net of the per-input fees only — the
+   * output fee is charged on the batch as a whole and is not attributed per
+   * coin — so it reports what the subdust coins are worth once each has paid
+   * its own way, and is not strictly a slice of `recoverable`. It can exceed
+   * `recoverable` where a flat output fee meets a wholly subdust wallet.
+   *
+   * The batch size caps are not applied here: they defer the overflow to the
+   * next cycle rather than reducing what is recoverable.
+   *
    * @returns Object containing recoverable amounts and subdust information
    *
    * @example
@@ -3286,17 +3426,29 @@ var VtxoManager = class _VtxoManager {
       withUnrolled: false
     });
     const dustAmount = getDustAmount(this.wallet);
-    const { vtxosToRecover, includesSubdust, totalAmount } = getRecoverableWithSubdust(
+    const { vtxosToRecover, includesSubdust } = getRecoverableWithSubdust(
       allVtxos,
       dustAmount,
       await fetchTimeHeight(this.wallet)
     );
-    const subdustAmount = vtxosToRecover.filter((v) => BigInt(v.value) < dustAmount).reduce((sum, v) => sum + BigInt(v.value), 0n);
+    const info = await this.getInfoProvider()?.getInfo();
+    const estimator = new Estimator(info?.fees.intentFee ?? {});
+    const { payable, net } = priceSettlementInputs(vtxosToRecover, estimator);
+    const priced = deductOffchainOutputFee(
+      subtotalOf(payable, net),
+      estimator,
+      await this.wallet.getAddress()
+    );
+    const recoverable = priced > 0n ? priced : 0n;
+    const subdustAmount = subtotalOf(
+      payable.filter((v) => BigInt(v.value) < dustAmount),
+      net
+    );
     return {
-      recoverable: totalAmount,
+      recoverable,
       subdust: subdustAmount,
       includesSubdust,
-      vtxoCount: vtxosToRecover.length
+      vtxoCount: payable.length
     };
   }
   // ========== Renewal Methods ==========
@@ -3414,6 +3566,14 @@ var VtxoManager = class _VtxoManager {
       }
       const info = await this.getInfoProvider()?.getInfo();
       const vtxoMaxAmount = info?.vtxoMaxAmount ?? -1n;
+      const estimator = new Estimator(info?.fees.intentFee ?? {});
+      const { payable, net } = priceSettlementInputs(vtxos, estimator);
+      vtxos = payable;
+      if (vtxos.length === 0) {
+        throw new Error(
+          "No VTXOs available to renew: every expiring VTXO is worth less than its own intent fee"
+        );
+      }
       const capped = capSettlementBatch(byExpiryAscending(vtxos, now), vtxoMaxAmount);
       if (vtxoMaxAmount >= 0n) {
         const oversized = vtxos.filter((vtxo) => BigInt(vtxo.value) > vtxoMaxAmount);
@@ -3431,24 +3591,28 @@ var VtxoManager = class _VtxoManager {
           );
         }
       }
-      const totalAmount = vtxos.reduce((sum, vtxo) => sum + vtxo.value, 0);
       const dustAmount = getDustAmount(this.wallet);
-      if (BigInt(totalAmount) < dustAmount) {
-        throw new Error(
-          `Total amount ${totalAmount} is below dust threshold ${dustAmount}`
-        );
-      }
       if (info && isMigrationCapable(this.wallet)) {
         await this.rotateForRecoverableInputs(vtxos, info);
       }
       const arkAddress = await this.wallet.getAddress();
+      const totalAmount = deductOffchainOutputFee(
+        subtotalOf(vtxos, net),
+        estimator,
+        arkAddress
+      );
+      if (totalAmount < dustAmount) {
+        throw new Error(
+          `Total amount ${totalAmount} is below dust threshold ${dustAmount}`
+        );
+      }
       const txid = await this.wallet.settle(
         {
           inputs: vtxos,
           outputs: [
             {
               address: arkAddress,
-              amount: BigInt(totalAmount)
+              amount: totalAmount
             }
           ]
         },
@@ -5218,6 +5382,7 @@ function serializeArkInfoSnapshot(info, savedAt) {
       forfeitPubkey: info.forfeitPubkey,
       unilateralExitDelay: info.unilateralExitDelay.toString(),
       boardingExitDelay: info.boardingExitDelay.toString(),
+      vtxoTreeExpiry: info.vtxoTreeExpiry?.toString(),
       sessionDuration: info.sessionDuration.toString(),
       dust: info.dust.toString(),
       fees: info.fees,
@@ -5267,6 +5432,7 @@ function hydrateArkInfo(snapshot) {
     sessionDuration: BigInt(a.sessionDuration),
     signerPubkey: a.signerPubkey,
     unilateralExitDelay: BigInt(a.unilateralExitDelay),
+    vtxoTreeExpiry: a.vtxoTreeExpiry !== void 0 ? BigInt(a.vtxoTreeExpiry) : void 0,
     utxoMaxAmount: BigInt(a.utxoMaxAmount),
     utxoMinAmount: BigInt(a.utxoMinAmount),
     version: a.version,
@@ -5339,6 +5505,9 @@ function parseStoredArkInfoSnapshot(raw) {
   ]) {
     assertDecimalString(a[field], `arkInfo.${field}`);
   }
+  if (a.vtxoTreeExpiry !== void 0) {
+    assertDecimalString(a.vtxoTreeExpiry, "arkInfo.vtxoTreeExpiry");
+  }
   assertFeeInfo(a.fees, "arkInfo.fees");
   if (!Array.isArray(a.deprecatedSigners)) {
     throw new MalformedArkInfoSnapshotError("arkInfo.deprecatedSigners must be an array");
@@ -11911,7 +12080,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
   }
 };
 var Wallet2 = class _Wallet extends ReadonlyWallet {
-  constructor(identity, network, onchainProvider, arkProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, dustAmount, walletRepository, contractRepository, renewalConfig, delegateProvider, watcherConfig, settlementConfig, walletContractTimelocks, receiveRotator, descriptorProvider, lookAheadWindow) {
+  constructor(identity, network, onchainProvider, arkProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, dustAmount, walletRepository, contractRepository, renewalConfig, delegateProvider, watcherConfig, settlementConfig, walletContractTimelocks, receiveRotator, descriptorProvider, lookAheadWindow, batchExpiryPolicy, checkpointExitDelayPolicy) {
     super(
       identity,
       network,
@@ -11930,6 +12099,8 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     this.arkProvider = arkProvider;
     this.forfeitOutputScript = forfeitOutputScript;
     this.forfeitPubkey = forfeitPubkey;
+    this.batchExpiryPolicy = batchExpiryPolicy;
+    this.checkpointExitDelayPolicy = checkpointExitDelayPolicy;
     this.identity = identity;
     this.renewalConfig = {
       enabled: renewalConfig?.enabled ?? false,
@@ -11962,6 +12133,8 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
   arkProvider;
   forfeitOutputScript;
   forfeitPubkey;
+  batchExpiryPolicy;
+  checkpointExitDelayPolicy;
   static MIN_FEE_RATE = 1;
   // sats/vbyte
   identity;
@@ -12260,12 +12433,10 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
    */
   async rotateServerSigner(newServerPubKey, checkpointTapscript) {
     const xonly = toXOnlyPubKey(newServerPubKey);
-    let newServerUnrollScript;
-    try {
-      newServerUnrollScript = CSVMultisigTapscript.decode(hex.decode(checkpointTapscript));
-    } catch (e) {
-      throw new Error("Invalid checkpointTapscript from server");
-    }
+    const newServerUnrollScript = assertValidServerUnrollScript(
+      checkpointTapscript,
+      resolveCheckpointExitDelayPolicy(this.network, this.checkpointExitDelayPolicy)
+    );
     if (equalBytes(xonly, this.arkServerPublicKey)) return;
     if (this._receiveRotator) {
       await this._receiveRotator.runExclusive(
@@ -12571,16 +12742,17 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
       throw new Error("Invalid configured public key");
     }
     const setup = await ReadonlyWallet.setupWalletConfig(config, pubkey);
-    let serverUnrollScript;
-    try {
-      const raw = hex.decode(setup.info.checkpointTapscript);
-      serverUnrollScript = CSVMultisigTapscript.decode(raw);
-    } catch (e) {
-      throw new Error("Invalid checkpointTapscript from server");
-    }
     const forfeitPubkey = hex.decode(setup.info.forfeitPubkey).slice(1);
     const forfeitAddress = Address(setup.network).decode(setup.info.forfeitAddress);
     const forfeitOutputScript = OutScript.encode(forfeitAddress);
+    const checkpointExitDelayOverrides = {
+      advertisedForfeitPubkey: forfeitPubkey,
+      ...config.minCheckpointExitDelaySeconds !== void 0 ? { minSeconds: config.minCheckpointExitDelaySeconds } : {}
+    };
+    const serverUnrollScript = assertValidServerUnrollScript(
+      setup.info.checkpointTapscript,
+      resolveCheckpointExitDelayPolicy(setup.network, checkpointExitDelayOverrides)
+    );
     const boot = await WalletReceiveRotator.resolveBoot(config, setup);
     const wallet = new _Wallet(
       config.identity,
@@ -12604,7 +12776,13 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
       setup.walletContractTimelocks,
       boot?.rotator,
       boot?.provider,
-      config.lookAheadWindow
+      config.lookAheadWindow,
+      // Pinned at setup rather than refetched per round.
+      {
+        advertisedVtxoTreeExpiry: setup.info.vtxoTreeExpiry,
+        ...config.minBatchExpirySeconds !== void 0 ? { minSeconds: config.minBatchExpirySeconds } : {}
+      },
+      checkpointExitDelayOverrides
     );
     wallet._serverInfoSource = setup.serverInfoSource;
     if (setup.serverInfoSource === "live") {
@@ -13192,24 +13370,20 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
         const utf8IntentId = new TextEncoder().encode(intentId);
         const intentIdHash = sha256(utf8IntentId);
         const intentIdHashStr = hex.encode(intentIdHash);
-        let skip = true;
-        for (const idHash of event.intentIdHashes) {
-          if (idHash === intentIdHashStr) {
-            if (!this.arkProvider) {
-              throw new Error("Arkade provider not configured");
-            }
-            await this.arkProvider.confirmRegistration(intentId);
-            skip = false;
-          }
-        }
+        const skip = !event.intentIdHashes.includes(intentIdHashStr);
         if (skip) {
           return { skip };
         }
+        if (!this.arkProvider) {
+          throw new Error("Arkade provider not configured");
+        }
+        const timelock = assertValidBatchExpiry(
+          event.batchExpiry,
+          resolveBatchExpiryPolicy(this.network, this.batchExpiryPolicy)
+        );
+        await this.arkProvider.confirmRegistration(intentId);
         const sweepTapscript = CSVMultisigTapscript.encode({
-          timelock: {
-            value: event.batchExpiry,
-            type: event.batchExpiry >= 512n ? "seconds" : "blocks"
-          },
+          timelock,
           pubkeys: [this.forfeitPubkey]
         }).script;
         sweepTapTreeRoot = tapLeafHash(sweepTapscript);
@@ -13645,8 +13819,9 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     }
     if (spendable.length > 0) {
       const info = await this.arkProvider.getInfo();
-      const serverUnrollScript = CSVMultisigTapscript.decode(
-        hex.decode(info.checkpointTapscript)
+      const serverUnrollScript = assertValidServerUnrollScript(
+        info.checkpointTapscript,
+        resolveCheckpointExitDelayPolicy(this.network, this.checkpointExitDelayPolicy)
       );
       for (const vtxo of spendable) {
         try {
@@ -14683,7 +14858,9 @@ var MessageBus = class {
         settlementConfig: config.settlementConfig,
         walletMode: config.walletMode,
         watcherConfig: config.watcherConfig,
-        lookAheadWindow: config.lookAheadWindow
+        lookAheadWindow: config.lookAheadWindow,
+        minBatchExpirySeconds: config.minBatchExpirySeconds,
+        minCheckpointExitDelaySeconds: config.minCheckpointExitDelaySeconds
       });
       return { wallet, arkProvider, readonlyWallet: wallet };
     }
@@ -17216,6 +17393,8 @@ var ServiceWorkerWallet = class _ServiceWorkerWallet extends ServiceWorkerReadon
       walletMode: options.walletMode,
       watcherConfig: options.watcherConfig,
       lookAheadWindow: options.lookAheadWindow,
+      minBatchExpirySeconds: options.minBatchExpirySeconds,
+      minCheckpointExitDelaySeconds: options.minCheckpointExitDelaySeconds,
       messageTimeouts
     };
     await initializeMessageBus(
@@ -19881,7 +20060,7 @@ __export(arkade_exports, {
   witnessRefToBytes: () => witnessRefToBytes
 });
 var isVtxoCoin = (input) => isVirtualCoin(input);
-function createArkadeBatchHandler(intentId, inputs, signer, signedProof, message, session, arkProvider, emulator, network, recipients) {
+function createArkadeBatchHandler(intentId, inputs, signer, signedProof, message, session, arkProvider, emulator, network, recipients, batchExpiryPolicy) {
   let batchId;
   let sweepTapTreeRoot;
   let validatedCommitmentTxid;
@@ -19891,15 +20070,19 @@ function createArkadeBatchHandler(intentId, inputs, signer, signedProof, message
       const intentIdHash = sha256(utf8IntentId);
       const intentIdHashStr = hex.encode(intentIdHash);
       if (!event.intentIdHashes.includes(intentIdHashStr)) return { skip: true };
+      const info = await arkProvider.getInfo();
+      const timelock = assertValidBatchExpiry(
+        event.batchExpiry,
+        resolveBatchExpiryPolicy(network, {
+          advertisedVtxoTreeExpiry: info.vtxoTreeExpiry,
+          ...batchExpiryPolicy
+        })
+      );
       await arkProvider.confirmRegistration(intentId);
       batchId = event.id;
       const sweepTapscript = CSVMultisigTapscript.encode({
-        timelock: {
-          value: event.batchExpiry,
-          // BIP-65: values >= 512 are interpreted as seconds, below as blocks
-          type: event.batchExpiry >= 512n ? "seconds" : "blocks"
-        },
-        pubkeys: [hex.decode((await arkProvider.getInfo()).forfeitPubkey).subarray(1)]
+        timelock,
+        pubkeys: [hex.decode(info.forfeitPubkey).subarray(1)]
       }).script;
       sweepTapTreeRoot = tapLeafHash(sweepTapscript);
       return { skip: false };
@@ -20919,6 +21102,6 @@ function isArkContract(str) {
   return str.startsWith(ARKCONTRACT_PREFIX + "=");
 }
 
-export { ARKADE_MAGIC, ActivityRegistry, AmbiguousRouteError, ArkNote, ArkadeCash, ArkadeCashCreateError, AssetManager, BIP21, BIP21Error, BIP322, Batch, ChainedTxType, ContractManager, ContractRepositoryImpl, ContractWatcher, DB_VERSION, DEFAULT_MESSAGE_TIMEOUTS, DelegateManagerImpl, DelegateNotConfiguredError, DelegatorManagerImpl, DelegatorNotConfiguredError, DescriptorIdentity, DescriptorSigningProviderMissingError, DustChangeError, ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, ESPLORA_URL, ElectrumOnchainProvider, EmulatorPacket, EsploraProvider, Estimator, Extension, ExtensionNotFoundError, HDDescriptorProvider, INTENT_TERMINAL_STATES, InMemoryContractRepository, InMemoryIntentRepository, InMemoryVirtualTxRepository, InMemoryWalletRepository, IndexedDBContractRepository, IndexedDBIntentRepository, IndexedDBVirtualTxRepository, IndexedDBWalletRepository, MESSAGE_BUS_INITIALIZING, MESSAGE_BUS_NOT_INITIALIZED, MIGRATION_KEY, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, MissingSigningDescriptorError, MnemonicIdentity, OnchainWallet, P2A, PaymentRouter, Ramps, ReadonlyAssetManager, ReadonlyDescriptorIdentity, ReadonlySingleKey, ReadonlyWallet, ReadonlyWalletError, RestDelegateProvider, RestDelegatorProvider, RestEmulatorProvider, SeedIdentity, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, SingleKey, TxTree, TxType, TxWeightEstimator, UnilateralExit, UnknownPacket, Unroll, VtxoManager, Wallet2 as Wallet, WalletMessageHandler, WalletNotInitializedError, WalletRepositoryImpl, WsElectrumChainSource, arkRail, arkTarget, arkade_exports, assertFinalCommitmentMatchesValidated, assertIntentIdUnique, assertSendableAmount, assertSubmittedArkTxid, assetMintResolver, boardingResolver, btcTarget, buildForfeitTx, buildOffchainTx, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, collabExitResolver, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, createAssetPacket, createDefaultActivityRegistry, createDefaultPaymentRouter, createExitChainResolver, decodeArkContract, deserializeAssets, deserializeExitPackage, deserializeUtxo, deserializeVtxo, encodeArkContract, extendVirtualCoinForContract, getMigrationStatus, getRandomId, hasBoardingTxExpired, hasCandidates, intentMatchesFilter, intentPageBounds, invoiceTarget, isArkContract, isBatchSignable, isBtcAddress, isCooperativelyMigratable, isDiscoverable, isHDDeterministicSignCapable, isHDWalletCapable, isLightningInvoice, isLnurl, isMessageBusInitializingError, isMessageBusNotInitializedError, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, isVtxoForScript, makeHandle, matchServerCheckpoints, mergeChainedTxType, migrateWalletRepository, onchainRail, openDatabase, requiresMigration, resolveSendAmount, rollbackMigration, saveVtxosForContract, scriptFromArkAddress, selectCoinsWithAsset, selectVirtualCoins, serializeAssets, serializeExitPackage, serializeUtxo, serializeVtxo, setupServiceWorker, signerSetFromInfo, toXOnlySignerHex, tryResolveSendAmount, validateBatchRecipients, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, warnAndFilterVtxosForScript };
-//# sourceMappingURL=chunk-T22257HW.js.map
-//# sourceMappingURL=chunk-T22257HW.js.map
+export { ARKADE_MAGIC, ActivityRegistry, AmbiguousRouteError, ArkNote, ArkadeCash, ArkadeCashCreateError, AssetManager, BIP21, BIP21Error, BIP322, Batch, ChainedTxType, ContractManager, ContractRepositoryImpl, ContractWatcher, DB_VERSION, DEFAULT_MESSAGE_TIMEOUTS, DEFAULT_MIN_BATCH_EXPIRY_SECONDS, DEFAULT_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, DelegateManagerImpl, DelegateNotConfiguredError, DelegatorManagerImpl, DelegatorNotConfiguredError, DescriptorIdentity, DescriptorSigningProviderMissingError, DustChangeError, ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, ESPLORA_URL, ElectrumOnchainProvider, EmulatorPacket, EsploraProvider, Estimator, Extension, ExtensionNotFoundError, HDDescriptorProvider, INTENT_TERMINAL_STATES, InMemoryContractRepository, InMemoryIntentRepository, InMemoryVirtualTxRepository, InMemoryWalletRepository, IndexedDBContractRepository, IndexedDBIntentRepository, IndexedDBVirtualTxRepository, IndexedDBWalletRepository, MESSAGE_BUS_INITIALIZING, MESSAGE_BUS_NOT_INITIALIZED, MIGRATION_KEY, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, MissingSigningDescriptorError, MnemonicIdentity, OnchainWallet, P2A, PaymentRouter, REGTEST_MIN_BATCH_EXPIRY_SECONDS, REGTEST_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, Ramps, ReadonlyAssetManager, ReadonlyDescriptorIdentity, ReadonlySingleKey, ReadonlyWallet, ReadonlyWalletError, RestDelegateProvider, RestDelegatorProvider, RestEmulatorProvider, SeedIdentity, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, SingleKey, TxTree, TxType, TxWeightEstimator, UnilateralExit, UnknownPacket, Unroll, VtxoManager, Wallet2 as Wallet, WalletMessageHandler, WalletNotInitializedError, WalletRepositoryImpl, WsElectrumChainSource, arkRail, arkTarget, arkade_exports, assertFinalCommitmentMatchesValidated, assertIntentIdUnique, assertSendableAmount, assertSubmittedArkTxid, assertValidBatchExpiry, assertValidServerUnrollScript, assetMintResolver, boardingResolver, btcTarget, buildForfeitTx, buildOffchainTx, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, collabExitResolver, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, createAssetPacket, createDefaultActivityRegistry, createDefaultPaymentRouter, createExitChainResolver, decodeArkContract, defaultBatchExpiryPolicy, defaultCheckpointExitDelayPolicy, deserializeAssets, deserializeExitPackage, deserializeUtxo, deserializeVtxo, encodeArkContract, extendVirtualCoinForContract, getMigrationStatus, getRandomId, hasBoardingTxExpired, hasCandidates, intentMatchesFilter, intentPageBounds, invoiceTarget, isArkContract, isBatchSignable, isBtcAddress, isCooperativelyMigratable, isDiscoverable, isHDDeterministicSignCapable, isHDWalletCapable, isLightningInvoice, isLnurl, isMessageBusInitializingError, isMessageBusNotInitializedError, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, isVtxoForScript, makeHandle, matchServerCheckpoints, mergeChainedTxType, migrateWalletRepository, onchainRail, openDatabase, requiresMigration, resolveBatchExpiryPolicy, resolveCheckpointExitDelayPolicy, resolveSendAmount, rollbackMigration, saveVtxosForContract, scriptFromArkAddress, selectCoinsWithAsset, selectVirtualCoins, serializeAssets, serializeExitPackage, serializeUtxo, serializeVtxo, setupServiceWorker, signerSetFromInfo, toXOnlySignerHex, tryResolveSendAmount, validateBatchRecipients, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, warnAndFilterVtxosForScript };
+//# sourceMappingURL=chunk-S3BFUTC5.js.map
+//# sourceMappingURL=chunk-S3BFUTC5.js.map