@arkade-os/sdk 0.5.0-rc.9 → 0.5.1

package/dist/index.d.cts

@@ -1,18 +1,23 @@
-import { a7 as ReadonlyIdentity, a as Identity, at as DescriptorSigningRequest, au as Transaction, ap as SignerSession, a5 as DescriptorProvider, av as IntentFeeConfig, aw as OffchainInput, ax as FeeAmount, ay as OnchainInput, az as FeeOutput, H as IntentRepository, J as ArkIntent, K as IntentFilter, O as Outpoint, L as VirtualTxRepository, M as VirtualTx, P as VtxoBranch, W as WalletRepository, z as ExtendedVirtualCoin, B as VtxoRepositoryKey, E as ExtendedCoin, g as ArkTransaction, D as WalletState, y as Contract, C as ContractRepository, F as ContractFilter, I as IWallet, t as ArkProvider, an as SettlementConfig, aA as ContractWatcherConfig, aB as Asset, R as Recipient, aC as FeeInfo, n as SettlementEvent, S as SettleParams, G as GetArkadeInfoOptions, aD as GetVtxosOptions, aE as PaginationOptions, f as GetVtxosFilter, aF as CreateContractParams, aG as GetContractsFilter, x as VirtualCoin, aH as GetSpendablePathsOptions, aI as GetAllSpendingPathsOptions, k as GetNewAddressesOptions, aJ as IssuanceParams, aK as ReissuanceParams, aL as BurnParams, aM as RenewVtxosOptions, A as ArkadeInfo, aN as NormalizedVtxoPage, c as ArkadeReader, d as ArkadeBroadcaster, e as WalletBalance, ae as ContractSyncState, ai as ContractWithVtxos, aO as WatchedScript, aP as PathSelection, l as NewAddress, aQ as ContractEvent, aR as AssetDetails, aS as IssuanceResult, aT as DelegateInfo, aU as MigrationGlobalSkipReason, aV as MigrationLegSkipReason, aW as SignerStatus, a6 as IReadonlyWallet, h as ActivityRegistry, ad as IReadonlyAssetManager, aX as StorageConfig, i as Activity, N as NormalizedExtendedVirtualCoin, j as IContractManager, p as IAssetManager, o as SendParams, m as IDelegateManager, aY as IVtxoManager, a8 as OnchainProvider, U as Network, ag as NetworkName, ak as Coin, aZ as SendBitcoinParams, a_ as ExplorerTransaction, aq as SignedIntent, ar as Intent, a$ as TreeNonces, b0 as TreePartialSigs, T as TxNotificationEvent, b1 as PendingTx, w as TapLeafScript, b2 as EncodedVtxoScript, X as CSVMultisigTapscript, v as RelativeTimelock, V as VtxoScript, b3 as Status, ah as ArkAddress, b4 as ChainTx, u as IndexerProvider, _ as TxTree, b5 as PathContext } from './index-BIL9boGL.cjs';
-export { b6 as ActivityIntent, b7 as ActivityResolver, b8 as ArkIntentState, b9 as ArkTapscript, ba as AssetMetadata, bb as BITCOIN_EMULATOR_PUBKEY, bc as BaseWalletConfig, a2 as BatchFailedEvent, a0 as BatchFinalizationEvent, a1 as BatchFinalizedEvent, bd as BatchInfo, be as BatchSignableIdentity, Y as BatchStartedEvent, bf as CLTVMultisigTapscript, bg as CandidateDeps, bh as ChainTxType, Q as ChainedTxType, bi as CommitmentTx, bj as ConditionCSVMultisigTapscript, bk as ConditionMultisigTapscript, bl as ContractBalance, bm as ContractEventCallback, bn as ContractHandler, al as ContractManager, am as ContractManagerConfig, bo as ContractState, bp as ContractVtxo, bq as ContractVtxoEvent, br as ContractWatcher, bs as DEFAULT_VTXO_PAGE_SIZE, bt as DelegateManagerImpl, bu as DelegateOptions, a9 as DelegateProvider, bv as DeprecatedSignerMigrationReport, bw as DeprecatedSignerReport, bx as DigestMismatchError, by as Discoverable, bz as DiscoveredContract, bA as DiscoveryDeps, bB as ESPLORA_URL, bC as EsploraProvider, bD as EventSourceCapable, bE as EventSourceFactory, bF as EventSourceLike, bG as EventSourceUnavailableError, ab as ExitCaptureMode, bH as ExitChainResolver, ac as ExitDataSource, bI as ExtendedContractVtxo, bJ as GroupMembership, bK as HandlerError, bL as INTENT_TERMINAL_STATES, bM as IndexerTxType, bN as IntentCoin, bO as KnownMetadata, bP as MUTINYNET_EMULATOR_PUBKEY, bQ as MigrateDeprecatedSignerOptions, bR as MigrationLegReport, bS as MigrationVtxoRef, bT as MultisigTapscript, bU as NewAddressType, bV as Nonces, bW as Output, bX as PageResponse, bY as PartialSig, bZ as PrevTxSource, b_ as PrevTxUnavailableError, b$ as ProviderClass, c0 as REGTEST_EMULATOR_PUBKEY, c1 as RawTxSource, aa as ReadonlyWalletConfig, af as RecipientArkadeAddressContext, q as RestArkProvider, c2 as RestDelegateProvider, r as RestIndexerProvider, c3 as ScanContractsOptions, c4 as ScanResult, c5 as ScheduledSession, c6 as SettlementEventType, c7 as SignRequest, c8 as SignerClassification, c9 as SignerSet, ca as SubscriptionEvent, cb as SubscriptionHeartbeat, s as SubscriptionResponse, cc as SweepTxNotification, cd as TapLeaves, ce as TapTreeCoder, cf as TapscriptType, as as TimeHeight, $ as TreeNoncesEvent, a4 as TreeSignatureEvent, Z as TreeSigningStartedEvent, a3 as TreeTxEvent, cg as Tx, ch as TxHistoryRecord, ci as TxKey, cj as TxNotification, ck as TxTag, cl as TxTreeNode, cm as TxType, cn as Vtxo, co as VtxoChain, ao as VtxoManager, cp as VtxoType, b as WalletConfig, cq as WalletMode, cr as WithPrevTx, cs as assertAllowedSighashTypes, ct as assertRecipientArkadeAddress, cu as assetMintResolver, cv as attachPrevArkTxs, cw as attachPrevoutTxs, cx as boardingResolver, cy as canRecoverOnchain, cz as canSpendOffchain, cA as canSweepOnchain, cB as classifyAgainstSignerSet, cC as classifyContractSigner, cD as collabExitResolver, cE as configureEventSource, cF as createDefaultActivityRegistry, cG as createExitChainResolver, cH as decodeTapscript, cI as defaultEmulatorPubkey, cJ as getAllNormalizedVtxos, cK as getConfiguredEventSource, cL as getNetwork, cM as getNormalizedVtxos, cN as getRandomId, cO as getSequence, cP as hasCandidates, cQ as hasTerminalSpend, cR as isBatchSignable, cS as isContractVtxoEvent, cT as isCooperativelyMigratable, cU as isDiscoverable, cV as isEventSourceUnavailableError, cW as isPastExpiry, cX as isSigningIdentity, cY as isSubdust, cZ as isTerminalIntentState, c_ as isVirtualCoin, c$ as isVtxoExpiringSoon, d0 as networkFromArkadeInfo, d1 as networks, d2 as resolveEmulatorPubkey, d3 as resolveEventSource, d4 as resolvePrevTxs, d5 as scriptFromTapLeafScript, d6 as signerSetFromInfo, d7 as toXOnlySignerHex, d8 as withPrevTxs } from './index-BIL9boGL.cjs';
-import { W as Wallet, R as ReadonlyWallet, b as ReceiveRotatorFactory, c as ReceiveRotatorBootOpts, d as ReceiveRotatorBoot, P as ProviderConnectionState, H as HDWalletCapable, a as HDAllocationCapable, A as AddressAllocationCapable, B as BatchExpiryPolicy, e as Batch } from './hdWalletCapable-D1ImQqlu.cjs';
-export { f as AbortError, g as ArkError, h as ArkErrorName, i as ArkadeCashClaimResult, j as ArkadeCashCreateError, k as ArkadeCashUnclaimedReason, l as ArkadeCashUnclaimedVtxo, m as BoardingUtxoGroup, C as CheckpointExitDelayPolicy, D as DEFAULT_MIN_BATCH_EXPIRY_SECONDS, n as DEFAULT_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, F as ForeignDescriptorError, I as IncomingFunds, M as MAX_USED_SIGNING_DESCRIPTORS_LOOK_AHEAD, o as MUTINYNET_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, p as ProviderKind, q as ProviderUnavailableError, r as REGTEST_MIN_BATCH_EXPIRY_SECONDS, s as REGTEST_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, S as SIGNET_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, t as ServerInfoSource, u as ServerResponseMismatchError, v as WaitForIncomingFundsOptions, w as WalletCannotAllocateAddressError, x as assertValidBatchExpiry, y as assertValidServerUnrollScript, z as defaultBatchExpiryPolicy, E as defaultCheckpointExitDelayPolicy, G as isAddressAllocationCapable, J as isArkError, K as isHDAllocationCapable, L as isHDWalletCapable, N as maybeArkError, O as resolveBatchExpiryPolicy, Q as resolveCheckpointExitDelayPolicy, T as resolveDescriptorSigner, U as selectVirtualCoins, V as signingDescriptorIndex, X as strictSigningDescriptorIndex, Y as waitForIncomingFunds } from './hdWalletCapable-D1ImQqlu.cjs';
-import { P as Program, A as ArkadeParamValue, a as ArkadeProgramScript, b as ProgramKeys, c as ArkadeArgValue, C as CompiledProgramFunction, d as ArkadeFunction, I as InputRef, e as InputDef, f as ArkadeValueType, g as ArkadeArgType, h as ArkadeContractParams, i as ArkadeSegment, j as AsmToken, S as SUPPORTED_PROGRAM_VERSION, k as SignerRef, T as TapscriptSegment, W as WitnessRef, l as deserializeArkadeContractParams, p as parseArtifact, r as resolveAsm, s as serializeArkadeContractParams, m as stringifyArtifact, v as validateProgram, w as witnessRefToBytes } from './index-DleNQcz5.cjs';
-export { n as ArkadeContractHandler, B as BoardingContractHandler, o as BoardingContractParams, D as DefaultContractHandler, q as DefaultContractParams, t as DelegateContractHandler, u as DelegateContractParams, V as VHTLC, x as VHTLCContractHandler, y as VHTLCContractParams, z as VHTLCV2ContractHandler, E as VHTLCV2ContractParams, F as contractHandlers } from './index-DleNQcz5.cjs';
-import { D as DefaultVtxo } from './delegate-Cyv2suFd.cjs';
-export { a as DelegateVtxo } from './delegate-Cyv2suFd.cjs';
+import { ah as ReadonlyIdentity, a as Identity, a4 as DescriptorSigningRequest, a5 as Transaction, aB as SignerSession, a3 as DescriptorProvider, aF as IntentFeeConfig, aG as OffchainInput, aH as FeeAmount, aI as OnchainInput, aJ as FeeOutput, Y as IntentRepository, Z as ArkIntent, _ as IntentPageFilter, P as PageRequest, F as PageResult, O as Outpoint, $ as VirtualTxRepository, a0 as VirtualTx, a1 as VtxoBranch, W as WalletRepository, D as ExtendedVirtualCoin, H as ScriptVtxoCursor, J as ScriptVtxoPageOptions, K as StoredVtxo, L as VtxoRepositoryKey, E as ExtendedCoin, M as TransactionHistoryPageFilter, Q as TransactionHistoryPageCursor, h as ArkTransaction, U as WalletState, B as Contract, C as ContractRepository, X as ContractFilter, I as IWallet, v as ArkProvider, ar as NetworkName, ai as OnchainProvider, az as SettlementConfig, aK as ContractWatcherConfig, aL as Asset, R as Recipient, aM as FeeInfo, o as SettlementEvent, N as NormalizedExtendedVirtualCoin, S as SettleParams, G as GetArkadeInfoOptions, aN as GetVtxosOptions, aO as PaginationOptions, f as GetVtxosFilter, g as GetSpendableVtxosFilter, aP as CreateContractParams, aQ as GetContractsFilter, z as VirtualCoin, aR as GetSpendablePathsOptions, aS as GetAllSpendingPathsOptions, l as GetNewAddressesOptions, aT as InputExpiryFloor, aU as IssuanceParams, aV as ReissuanceParams, aW as BurnParams, aX as RenewVtxosOptions, A as ArkadeInfo, aY as NormalizedVtxoPage, c as ArkadeReader, d as ArkadeBroadcaster, e as WalletBalance, ao as ContractSyncState, at as ContractWithVtxos, aZ as WatchedScript, a_ as PathSelection, m as NewAddress, a$ as ContractEvent, b0 as AssetDetails, b1 as IssuanceResult, b2 as DelegateInfo, b3 as MigrationGlobalSkipReason, b4 as MigrationLegSkipReason, b5 as SignerStatus, ag as IReadonlyWallet, i as ActivityRegistry, an as IReadonlyAssetManager, b6 as StorageConfig, j as Activity, k as IContractManager, q as IAssetManager, p as SendParams, n as IDelegateManager, b7 as IVtxoManager, a6 as Network, av as Coin, b8 as SendBitcoinParams, b9 as ExplorerTransaction, aC as SignedIntent, aD as Intent, ba as TreeNonces, bb as TreePartialSigs, T as TxNotificationEvent, bc as PendingTx, y as TapLeafScript, bd as EncodedVtxoScript, ay as CSVMultisigTapscript, x as RelativeTimelock, be as EmulatorProvider, V as VtxoScript, bf as Status, as as ArkAddress, bg as ChainTx, w as IndexerProvider, a9 as TxTree, bh as ArkadeService, bi as ContractVtxoEvent, bj as ExtendedContractVtxo, bk as ResolvedArkadeService, bl as resolveArkadeService, bm as PathContext } from './index-B3fRWO5i.cjs';
+export { bn as ActivityIntent, bo as ActivityResolver, bp as ArkIntentState, bq as ArkTapscript, br as AssetMetadata, bs as BITCOIN_EMULATOR_PUBKEY, bt as BaseWalletConfig, ad as BatchFailedEvent, ab as BatchFinalizationEvent, ac as BatchFinalizedEvent, bu as BatchInfo, bv as BatchSignableIdentity, a7 as BatchStartedEvent, bw as CLTVMultisigTapscript, bx as CandidateDeps, by as ChainTxType, a2 as ChainedTxType, bz as CommitmentTx, bA as ConditionCSVMultisigTapscript, bB as ConditionMultisigTapscript, bC as ConnectorTreeNode, bD as ContractBalance, bE as ContractEventCallback, bF as ContractHandler, aw as ContractManager, ax as ContractManagerConfig, bG as ContractState, bH as ContractVtxo, bI as ContractWatcher, bJ as ContractWatcherEventCallback, bK as DEFAULT_ARKADE_EMULATOR_URL, bL as DEFAULT_VTXO_PAGE_SIZE, bM as DelegateManagerImpl, bN as DelegateOptions, aj as DelegateProvider, bO as DeprecatedSignerMigrationReport, bP as DeprecatedSignerReport, bQ as DigestMismatchError, bR as Discoverable, bS as DiscoveredContract, bT as DiscoveryDeps, bU as ESPLORA_URL, bV as EmulatorInfo, aq as EsploraProvider, bW as EventSourceCapable, bX as EventSourceFactory, bY as EventSourceLike, bZ as EventSourceUnavailableError, al as ExitCaptureMode, b_ as ExitChainResolver, am as ExitDataSource, b$ as GroupMembership, c0 as HandlerError, c1 as INTENT_TERMINAL_STATES, c2 as IndexerTxType, c3 as IntentCoin, c4 as IntentFilter, c5 as KnownMetadata, c6 as MAX_PAGE_SIZE, c7 as MUTINYNET_EMULATOR_PUBKEY, c8 as MigrateDeprecatedSignerOptions, c9 as MigrationLegReport, ca as MigrationVtxoRef, cb as MultisigTapscript, cc as NewAddressType, cd as Nonces, ce as Output, cf as PageResponse, cg as PartialSig, ch as PrevTxSource, ci as PrevTxUnavailableError, cj as ProviderClass, ck as REGTEST_EMULATOR_PUBKEY, cl as RawTxSource, ak as ReadonlyWalletConfig, ap as RecipientArkadeAddressContext, cm as RenewalSplit, cn as RenewalSplitContext, r as RestArkProvider, co as RestDelegateProvider, cp as RestEmulatorProvider, s as RestIndexerProvider, cq as ScanContractsOptions, cr as ScanResult, cs as ScheduledSession, ct as SettlementEventType, cu as SignRequest, cv as SignerClassification, cw as SignerSet, t as SubscriptionEvent, cx as SubscriptionFilter, u as SubscriptionHeartbeat, cy as SubscriptionResponse, cz as SweepTxNotification, cA as TapLeaves, cB as TapTreeCoder, cC as TapscriptType, aE as TimeHeight, aa as TreeNoncesEvent, af as TreeSignatureEvent, a8 as TreeSigningStartedEvent, ae as TreeTxEvent, cD as Tx, cE as TxHistoryRecord, cF as TxKey, cG as TxNotification, cH as TxTag, cI as TxTreeNode, cJ as TxType, cK as Vtxo, cL as VtxoChain, aA as VtxoManager, cM as VtxoType, b as WalletConfig, cN as WalletMode, cO as WithPrevTx, cP as assertAllowedSighashTypes, cQ as assertPageRequest, cR as assertRecipientArkadeAddress, cS as assetMintResolver, cT as attachPrevArkTxs, cU as attachPrevoutTxs, cV as boardingResolver, cW as canRecoverOnchain, cX as canSpendOffchain, cY as canSweepOnchain, cZ as classifyAgainstSignerSet, c_ as classifyContractSigner, c$ as collabExitResolver, d0 as collectContracts, d1 as collectIntents, d2 as collectPages, d3 as collectScriptVtxos, d4 as collectTransactionHistory, d5 as collectUtxos, d6 as collectVtxos, d7 as configureEventSource, d8 as createDefaultActivityRegistry, d9 as createExitChainResolver, da as decodeTapscript, db as defaultEmulatorPubkey, dc as getAllNormalizedVtxos, dd as getConfiguredEventSource, de as getNetwork, df as getNormalizedVtxos, dg as getRandomId, dh as getSequence, di as hasCandidates, dj as isBatchSignable, dk as isContractVtxoEvent, dl as isCooperativelyMigratable, dm as isDiscoverable, dn as isEventSourceUnavailableError, dp as isPastExpiry, dq as isSigningIdentity, dr as isSubdust, ds as isTerminalIntentState, dt as isVirtualCoin, du as isVtxoExpiringSoon, dv as isVtxoSpent, dw as iteratePages, dx as networkFromArkadeInfo, dy as networks, dz as pageResult, dA as resolveEmulatorPubkey, dB as resolveEventSource, dC as resolvePrevTxs, dD as scriptFromTapLeafScript, dE as signerSetFromInfo, dF as toOffchainInputFeeParams, dG as toXOnlySignerHex, dH as withPrevTxs } from './index-B3fRWO5i.cjs';
+import { W as Wallet, R as ReadonlyWallet, b as ReceiveRotatorFactory, c as ReceiveRotatorBootOpts, d as ReceiveRotatorBoot, P as ProviderConnectionState, H as HDWalletCapable, a as HDAllocationCapable, A as AddressAllocationCapable, B as BatchExpiryPolicy, e as Batch } from './wallet-D9dvXu-K.cjs';
+export { f as AbortError, g as ArkError, h as ArkErrorName, i as ArkadeCashClaimResult, j as ArkadeCashCreateError, k as ArkadeCashOperatorMismatchError, l as ArkadeCashUnclaimedReason, m as ArkadeCashUnclaimedVtxo, n as ArkadeCashVtxoRef, o as BoardingUtxoGroup, D as DEFAULT_MIN_BATCH_EXPIRY_SECONDS, F as ForeignDescriptorError, I as IncomingFunds, p as IndexedDBWalletRepository, K as KeyringDescriptorProvider, M as MAX_USED_SIGNING_DESCRIPTORS_LOOK_AHEAD, q as ProviderKind, r as ProviderUnavailableError, s as REGTEST_MIN_BATCH_EXPIRY_SECONDS, S as ServerInfoSource, t as ServerResponseMismatchError, V as VtxoReservation, u as VtxoReservedError, v as WaitForIncomingFundsOptions, w as WalletCannotAllocateAddressError, x as assertValidBatchExpiry, y as defaultBatchExpiryPolicy, z as isAddressAllocationCapable, C as isArkError, E as isHDAllocationCapable, G as isHDWalletCapable, J as maybeArkError, L as resolveBatchExpiryPolicy, N as resolveDescriptorSigner, O as selectVirtualCoins, Q as signingDescriptorIndex, T as strictSigningDescriptorIndex, U as waitForIncomingFunds } from './wallet-D9dvXu-K.cjs';
+import { P as Program, A as ArkadeParamValue, a as ArkadeProgramScript, b as ProgramKeys, c as ArkadeArgValue, C as CompiledProgramFunction, d as ArkadeFunction, I as InputDef, e as ArkadeValueType, f as ArkadeArgType, g as ArkadeContractParams, h as ArkadeSegment, i as AsmToken, j as InputRef, S as SUPPORTED_PROGRAM_VERSION, k as SignerRef, T as TapscriptSegment, l as TweakedSigner, U as UnsupportedProgramVersionError, W as WitnessRef, m as deserializeArkadeContractParams, p as parseArtifact, r as resolveAsm, s as serializeArkadeContractParams, n as stringifyArtifact, v as validateProgram, w as witnessRefToBytes } from './index-Fpf4mQZr.cjs';
+export { o as ArkadeContractHandler, B as BoardingContractHandler, q as BoardingContractParams, D as DefaultContractHandler, t as DefaultContractParams, u as DelegateContractHandler, x as DelegateContractParams, V as VHTLC, y as VHTLCContractHandler, z as VHTLCContractParams, E as VHTLCV2ContractHandler, F as VHTLCV2ContractParams, G as contractHandlers } from './index-Fpf4mQZr.cjs';
+import { D as DefaultVtxo } from './delegate-CFCfrReG.cjs';
+export { a as DelegateVtxo } from './delegate-CFCfrReG.cjs';
 import { Bytes, BTC_NETWORK } from '@scure/btc-signer/utils.js';
 import { P2TR } from '@scure/btc-signer/payment.js';
 import { Transaction as Transaction$1, OP, Script, ScriptType } from '@scure/btc-signer';
 import { ElectrumWS } from 'ws-electrumx-client';
 import { TransactionOutput, TransactionInputUpdate } from '@scure/btc-signer/psbt.js';
-import { Transaction as Transaction$2 } from '@scure/btc-signer/transaction.js';
 import * as P from 'micro-packed';
+import '@scure/btc-signer/transaction.js';
+
+/** Validate an optional millisecond duration; zero retains its caller-defined meaning. */
+declare function assertNonNegativeMs(name: string, ms: number | undefined): void;
+/** Validate a timer delay without changing whether zero disables or immediately fires it. */
+declare function assertTimerMs(name: string, ms: number | undefined): void;
 
 /**
  * Tagged envelope for a signing identity transported across the
@@ -109,9 +114,8 @@ interface NetworkOptions {
 /** Used for a caller-supplied account-descriptor template. */
 interface DescriptorOptions {
     /**
-     * Account-descriptor *template* — must end with the BIP-32 wildcard
-     * suffix `/*)`. Stored as-is on {@link SeedIdentity.descriptor} and
-     * read by HD providers to rotate through derivation indices.
+     * Account-descriptor *template*; must end with the BIP-32 wildcard suffix `/*)`. Stored as-is
+     * on {@link SeedIdentity.descriptor} for HD providers to rotate through indices.
      */
     descriptor: string;
 }
@@ -123,32 +127,18 @@ type MnemonicOptions = SeedIdentityOptions & {
     passphrase?: string;
 };
 /**
- * Seed-based identity derived from a raw seed and an account descriptor
- * *template*.
- *
- * This is the recommended identity type for most applications. It uses
- * standard BIP86 (Taproot) derivation by default; callers that need a
- * different path supply the wildcard template directly.
+ * Seed-based identity derived from a raw seed and an account descriptor *template*.
  *
- * Prefer this (or @see MnemonicIdentity) over `SingleKey` for new
- * integrations — `SingleKey` exists for backward compatibility with
- * raw nsec-style keys.
+ * The recommended identity type: BIP86 (Taproot) derivation by default, or a caller-supplied
+ * wildcard template. Prefer it (or @see MnemonicIdentity) over `SingleKey`, which exists for
+ * backward compatibility with raw nsec-style keys.
  *
- * The identity holds the wildcard *template* (e.g.
- * `tr([fp/86'/0'/0']xpub/0/*)`) on its public {@link descriptor}
- * field. HD rotation reads it directly; consumers that need a
- * concrete descriptor at a specific index materialize it themselves
- * (see `HDDescriptorProvider` in the wallet layer).
+ * {@link descriptor} holds the wildcard template (e.g. `tr([fp/86'/0'/0']xpub/0/*)`); consumers
+ * materialize concrete indices themselves (see `HDDescriptorProvider`).
  *
- * Exposes seed-level primitives (signing, derivation, the template)
- * but is deliberately NOT a `DescriptorProvider`. Wrap it explicitly
- * to get one:
- *  - `HDDescriptorProvider` for rotating receive addresses.
- *  - {@link StaticDescriptorProvider} for legacy, single-key behaviour.
- *
- * The split prevents a SeedIdentity from being silently used as a
- * concrete descriptor source, which would defeat HD rotation without
- * any compile-time signal that something was wrong.
+ * Deliberately NOT a `DescriptorProvider`, so it can't silently be used as a concrete
+ * descriptor source and defeat HD rotation. Wrap it in `HDDescriptorProvider` (rotating
+ * receive addresses) or {@link StaticDescriptorProvider} (legacy single-key behaviour).
  *
  * @example
  * ```typescript
@@ -166,34 +156,21 @@ type MnemonicOptions = SeedIdentityOptions & {
  */
 declare class SeedIdentity implements HDCapableIdentity {
     private readonly derivedKey;
-    /**
-     * Wildcard account-descriptor template (e.g.
-     * `tr([fp/86'/0'/0']xpub/0/*)`). The canonical thing to pass
-     * through the system; consumers materialize a concrete descriptor
-     * at a specific index themselves (see `HDDescriptorProvider` in
-     * the wallet layer for the rotating-counter use case).
-     */
+    /** Wildcard account-descriptor template (e.g. `tr([fp/86'/0'/0']xpub/0/*)`). */
     readonly descriptor: string;
     /**
-     * Constructs a SeedIdentity from a 64-byte seed and either a
-     * caller-supplied wildcard descriptor (`{ descriptor }`) or the
-     * default BIP86 path at the requested network (`{ isMainnet }`).
-     * Prefer the {@link fromSeed} factory for symmetry with
-     * {@link MnemonicIdentity.fromMnemonic}.
+     * Constructs a SeedIdentity from a 64-byte seed and either a wildcard `{ descriptor }` or the
+     * default BIP86 path for `{ isMainnet }`. Prefer {@link fromSeed}.
      *
-     * Throws on a non-wildcard descriptor, an xpub mismatch with the
-     * seed, or a missing derivation path.
+     * Throws on a non-wildcard descriptor, an xpub mismatch with the seed, or a missing
+     * derivation path.
      */
     constructor(seed: Uint8Array, opts?: SeedIdentityOptions);
     /**
-     * Creates a SeedIdentity from a raw 64-byte seed.
-     *
-     * Pass `{ isMainnet }` for default BIP86 derivation, or
-     * `{ descriptor }` for a caller-supplied account-descriptor
-     * template (the option's value must end with `/*)`).
+     * Creates a SeedIdentity from a raw 64-byte seed: `{ isMainnet }` for default BIP86
+     * derivation, or `{ descriptor }` for a template ending in `/*)`.
      *
      * @param seed - 64-byte seed (typically from mnemonicToSeedSync)
-     * @param opts - Network selection or descriptor template.
      */
     static fromSeed(seed: Uint8Array, opts?: SeedIdentityOptions): SeedIdentity;
     xOnlyPublicKey(): Promise<Uint8Array>;
@@ -201,22 +178,13 @@ declare class SeedIdentity implements HDCapableIdentity {
     sign(tx: Transaction, inputIndexes?: number[]): Promise<Transaction>;
     signMessage(message: Uint8Array, signatureType?: "schnorr" | "ecdsa"): Promise<Uint8Array>;
     /**
-     * BIP-340 sign `messageHash` with this identity's own key, aux_rand = 0.
-     *
-     * The descriptor-less sibling of
-     * {@link signSchnorrDeterministicWithDescriptor}, for an `auto`-mode wallet
-     * whose bare `tr(pubkey)` resolves to the identity itself rather than to a
-     * {@link DescriptorIdentity}. Deliberately NOT routed through
-     * `signMessage`, whose schnorr branch draws a random aux_rand and would
-     * make the "deterministic" signature unreproducible.
+     * BIP-340 sign `messageHash` with this identity's own key, aux_rand = 0 (for an `auto`-mode
+     * wallet whose bare `tr(pubkey)` resolves to the identity itself). NOT via `signMessage`,
+     * whose random aux_rand would make the signature unreproducible.
      */
     signSchnorrDeterministic(messageHash: Uint8Array): Promise<Uint8Array>;
     signerSession(): SignerSession;
-    /**
-     * Converts to a watch-only identity that cannot sign. Carries the
-     * template forward, so the readonly side stays HD-capable (can
-     * derive descriptors at any index without seed access).
-     */
+    /** Watch-only copy; carries the template forward, so it stays HD-capable without the seed. */
     toReadonly(): Promise<ReadonlyDescriptorIdentity>;
     /** Returns true when `descriptor` is derived from this identity's seed. */
     ownsDescriptor(descriptor: string): boolean;
@@ -238,12 +206,8 @@ declare class SeedIdentity implements HDCapableIdentity {
     private signMessageWithKey;
 }
 /**
- * Mnemonic-based identity derived from a BIP39 phrase.
- *
- * This is the most user-friendly identity type — recommended for wallet
- * applications where users manage their own backup phrase. Extends
- * @see SeedIdentity with mnemonic validation and optional passphrase
- * support.
+ * Mnemonic-based identity derived from a BIP39 phrase; recommended where users manage their own
+ * backup phrase. Extends @see SeedIdentity with mnemonic validation and an optional passphrase.
  *
  * @example
  * ```typescript
@@ -256,27 +220,16 @@ declare class SeedIdentity implements HDCapableIdentity {
 declare class MnemonicIdentity extends SeedIdentity {
     private constructor();
     /**
-     * Creates a MnemonicIdentity from a BIP39 mnemonic phrase.
-     *
-     * Pass `{ isMainnet }` for default BIP86 derivation, or
-     * `{ descriptor }` for a caller-supplied account-descriptor
-     * template (the option's value must end with `/*)`).
+     * Creates a MnemonicIdentity from a BIP39 phrase: `{ isMainnet }` for default BIP86
+     * derivation, or `{ descriptor }` for a template ending in `/*)`, plus optional passphrase.
      *
      * @param phrase - BIP39 mnemonic phrase (12 or 24 words)
-     * @param opts - Network selection or descriptor template, plus optional passphrase
      */
     static fromMnemonic(phrase: string, opts?: MnemonicOptions): MnemonicIdentity;
 }
 /**
- * Watch-only HD identity from a descriptor *template*.
- *
- * Can derive public keys but cannot sign transactions. Use this for
- * watch-only wallets — given just an xpub-based template, the readonly
- * side still rotates through HD indices.
- *
- * Constructed from a wildcard template (e.g.
- * `tr([fp/86'/0'/0']xpub.../0/*)`); the {@link descriptor} field
- * holds it for HD providers to consume.
+ * Watch-only HD identity from a wildcard descriptor template (e.g.
+ * `tr([fp/86'/0'/0']xpub.../0/*)`): derives public keys and rotates HD indices, cannot sign.
  *
  * @example
  * ```typescript
@@ -289,26 +242,14 @@ declare class MnemonicIdentity extends SeedIdentity {
  */
 declare class ReadonlyDescriptorIdentity implements ReadonlyHDCapableIdentity {
     /**
-     * Index-0 expansion of {@link descriptor}. Both the x-only pubkey
-     * (taproot, returned by the library as 32 bytes) and the compressed
-     * pubkey (derived through the bip32 node when needed) are read off
-     * this on demand — no separate caches.
+     * Index-0 expansion of {@link descriptor}; the x-only pubkey (32 bytes) and the compressed
+     * pubkey (via the bip32 node) are both read off it on demand.
      */
     private readonly indexZero;
-    /**
-     * Wildcard account-descriptor template (e.g.
-     * `tr([fp/86'/0'/0']xpub/0/*)`). HD rotation consumers materialize
-     * a concrete descriptor at a specific index themselves.
-     */
+    /** Wildcard account-descriptor template (e.g. `tr([fp/86'/0'/0']xpub/0/*)`). */
     readonly descriptor: string;
     private constructor();
-    /**
-     * Creates a ReadonlyDescriptorIdentity from an account-descriptor
-     * *template* (must end with the BIP-32 wildcard suffix `/*)`).
-     *
-     * @param descriptor - Wildcard-suffixed Taproot template
-     *   (`tr([fp/path']xpub.../child/*)`).
-     */
+    /** @param descriptor - Wildcard-suffixed Taproot template (`tr([fp/path']xpub.../child/*)`). */
     static fromDescriptor(descriptor: string): ReadonlyDescriptorIdentity;
     xOnlyPublicKey(): Promise<Uint8Array>;
     compressedPublicKey(): Promise<Uint8Array>;
@@ -430,73 +371,19 @@ declare class DescriptorIdentity implements Identity {
 }
 
 /**
- * In-memory single key implementation for Bitcoin transaction signing.
- *
- * @example
- * ```typescript
- * // Create from hex string
- * const key = SingleKey.fromHex('your_private_key_hex');
- *
- * // Create from raw bytes
- * const key = SingleKey.fromPrivateKey(privateKeyBytes);
- *
- * // Create random key
- * const randomKey = SingleKey.fromRandomBytes();
- *
- * // Sign a transaction
- * const signedTx = await key.sign(transaction);
- * ```
+ * Wraps a legacy Identity (single-key) as a DescriptorProvider.
+ * The descriptor is always a simple tr(pubkey) format.
  */
-declare class SingleKey implements Identity {
-    private key;
-    private constructor();
-    /** Create a signing identity from raw private key bytes. */
-    static fromPrivateKey(privateKey: Uint8Array): SingleKey;
-    /** Create a signing identity from a hex-encoded private key. */
-    static fromHex(privateKeyHex: string): SingleKey;
-    /** Create a signing identity with a freshly generated random private key. */
-    static fromRandomBytes(): SingleKey;
-    /**
-     * Export the private key as a hex string.
-     *
-     * @returns The private key as a hex string
-     */
-    toHex(): string;
-    sign(tx: Transaction, inputIndexes?: number[]): Promise<Transaction>;
-    compressedPublicKey(): Promise<Uint8Array>;
-    xOnlyPublicKey(): Promise<Uint8Array>;
-    signerSession(): SignerSession;
-    signMessage(message: Uint8Array, signatureType?: "schnorr" | "ecdsa"): Promise<Uint8Array>;
-    /**
-     * BIP-340 sign `messageHash` with aux_rand = 0, so the signature — and
-     * anything derived from it — is reproducible from the key alone.
-     *
-     * What lets a static wallet derive a swap preimage instead of storing one
-     * (see `wallet/contractSecrets.ts`). Deliberately NOT `signMessage`, whose
-     * schnorr branch draws a random aux_rand: a preimage derived from that is
-     * unrecoverable, and the loss would only surface at claim time.
-     */
-    signSchnorrDeterministic(messageHash: Uint8Array): Promise<Uint8Array>;
-    toReadonly(): Promise<ReadonlySingleKey>;
-}
-declare class ReadonlySingleKey implements ReadonlyIdentity {
-    private readonly publicKey;
-    /** Create a readonly identity from a compressed public key. */
-    constructor(publicKey: Uint8Array);
-    /**
-     * Create a ReadonlySingleKey from a compressed public key.
-     *
-     * @param publicKey - 33-byte compressed public key (02/03 prefix + 32-byte x coordinate)
-     * @returns A new ReadonlySingleKey instance
-     * @example
-     * ```typescript
-     * const pubkey = new Uint8Array(33); // your compressed public key
-     * const readonlyKey = ReadonlySingleKey.fromPublicKey(pubkey);
-     * ```
-     */
-    static fromPublicKey(publicKey: Uint8Array): ReadonlySingleKey;
-    xOnlyPublicKey(): Promise<Uint8Array>;
-    compressedPublicKey(): Promise<Uint8Array>;
+declare class StaticDescriptorProvider implements DescriptorProvider {
+    private readonly identity;
+    private readonly descriptor;
+    private readonly pubKeyHex;
+    constructor(identity: Identity, pubKeyHex: string);
+    static create(identity: Identity): Promise<StaticDescriptorProvider>;
+    getNextSigningDescriptor(): Promise<string>;
+    isOurs(descriptor: string): boolean;
+    signWithDescriptor(requests: DescriptorSigningRequest[]): Promise<Transaction[]>;
+    signMessageWithDescriptor(descriptor: string, message: Uint8Array, type?: "schnorr" | "ecdsa"): Promise<Uint8Array>;
 }
 
 /**
@@ -553,7 +440,7 @@ declare class InMemoryIntentRepository implements IntentRepository {
     private byId;
     clear(): Promise<void>;
     saveIntent(intent: ArkIntent): Promise<void>;
-    getIntents(filter?: IntentFilter): Promise<ArkIntent[]>;
+    getIntentsPage(filter: IntentPageFilter | undefined, page: PageRequest): Promise<PageResult<ArkIntent>>;
     getLockedVtxoOutpoints(): Promise<Outpoint[]>;
     [Symbol.asyncDispose](): Promise<void>;
 }
@@ -573,11 +460,8 @@ declare class InMemoryVirtualTxRepository implements VirtualTxRepository {
 }
 
 /**
- * @experimental Virtual-tx persistence is inert by default. This repository
- * opens its DB at {@link INTENT_DB_VERSION} and creates the virtualtx stores,
- * so it must be given a *dedicated* `dbName` distinct from the wallet/contract
- * DB until this persistence is activated in the shared schema — otherwise the
- * shared DB's version-conflict guard rejects the mismatched open.
+ * @experimental Virtual-tx persistence is opt-in. Stored in its own database,
+ * {@link BATCHES_DB_NAME} by default, never in the wallet/contract one.
  */
 declare class IndexedDBVirtualTxRepository implements VirtualTxRepository {
     readonly version: 1;
@@ -595,11 +479,8 @@ declare class IndexedDBVirtualTxRepository implements VirtualTxRepository {
 }
 
 /**
- * @experimental Intent persistence is inert by default. This repository opens
- * its DB at {@link INTENT_DB_VERSION} and creates the intent stores, so it must
- * be given a *dedicated* `dbName` distinct from the wallet/contract DB until
- * intent persistence is activated in the shared schema — otherwise the shared
- * DB's version-conflict guard rejects the mismatched open.
+ * @experimental Intent persistence is opt-in. Stored in its own database,
+ * {@link BATCHES_DB_NAME} by default, never in the wallet/contract one.
  */
 declare class IndexedDBIntentRepository implements IntentRepository {
     readonly version: 1;
@@ -608,7 +489,7 @@ declare class IndexedDBIntentRepository implements IntentRepository {
     private getDB;
     clear(): Promise<void>;
     saveIntent(intent: ArkIntent): Promise<void>;
-    getIntents(filter?: IntentFilter): Promise<ArkIntent[]>;
+    getIntentsPage(filter: IntentPageFilter | undefined, page: PageRequest): Promise<PageResult<ArkIntent>>;
     getLockedVtxoOutpoints(): Promise<Outpoint[]>;
     [Symbol.asyncDispose](): Promise<void>;
 }
@@ -618,21 +499,21 @@ declare class IndexedDBIntentRepository implements IntentRepository {
  * Data is ephemeral and scoped to the instance.
  */
 declare class InMemoryWalletRepository implements WalletRepository {
-    readonly version: 1;
+    readonly version: 2;
     private readonly vtxosByAddress;
     private readonly utxosByAddress;
     private readonly txsByAddress;
     private walletState;
-    getVtxos(address: string): Promise<ExtendedVirtualCoin[]>;
+    getVtxosPage(address: string, page: PageRequest<Outpoint>): Promise<PageResult<ExtendedVirtualCoin, Outpoint>>;
     saveVtxos(address: string, vtxos: ExtendedVirtualCoin[]): Promise<void>;
     deleteVtxos(address: string): Promise<void>;
-    getVtxosForScript(script: string): Promise<ExtendedVirtualCoin[]>;
+    getVtxosForScriptPage(script: string, page: PageRequest<ScriptVtxoCursor>, options?: ScriptVtxoPageOptions): Promise<PageResult<StoredVtxo, ScriptVtxoCursor>>;
     saveVtxosForScript(key: VtxoRepositoryKey, vtxos: ExtendedVirtualCoin[]): Promise<void>;
     deleteVtxosForScript(script: string): Promise<void>;
-    getUtxos(address: string): Promise<ExtendedCoin[]>;
-    saveUtxos(address: string, utxos: ExtendedCoin[]): Promise<void>;
+    getUtxosPage(address: string, page: PageRequest<Outpoint>): Promise<PageResult<ExtendedCoin, Outpoint>>;
+    saveUtxos(addressOrBatch: string | ReadonlyMap<string, ExtendedCoin[]>, utxos?: ExtendedCoin[]): Promise<void>;
     deleteUtxos(address: string): Promise<void>;
-    getTransactionHistory(address: string): Promise<ArkTransaction[]>;
+    getTransactionHistoryPage(filter: TransactionHistoryPageFilter, page: PageRequest<TransactionHistoryPageCursor>): Promise<PageResult<ArkTransaction, TransactionHistoryPageCursor>>;
     saveTransactions(address: string, txs: ArkTransaction[]): Promise<void>;
     deleteTransactions(address: string): Promise<void>;
     getWalletState(): Promise<WalletState | null>;
@@ -642,11 +523,8 @@ declare class InMemoryWalletRepository implements WalletRepository {
 }
 
 /**
- * Whether generic wallet spending may select this contract's VTXOs.
- *
- * Default closed: a type whose handler declares nothing — a custom type, a
- * plugin type, a row whose handler is not registered in this context — is not
- * spendable. Every shipped handler answers explicitly.
+ * Whether generic wallet spending may select this contract's VTXOs. Default closed: a type whose
+ * handler declares nothing, or has no handler registered here, is not spendable.
  *
  * @see ContractHandler.isGenericallySpendable
  */
@@ -665,68 +543,44 @@ type ExcludableVtxo = {
 /** {@link gatedContracts}' answer, as callers that only read it should take it. */
 type GatedContracts = ReadonlyMap<string, string>;
 /**
- * Why generic spending skips a VTXO, or `undefined` when it does not — phrased
- * to follow the outpoint in a log line.
- *
- * Generic spending applies three exclusions (the contract gate, pending
- * recovery, intent locks) that key on different things — script, script,
- * outpoint. Stating each as a reason-or-undefined lets all three report through
- * one path, so no exclusion can drop a coin silently while another logs.
+ * Why generic spending skips a VTXO, or `undefined` when it does not; phrased to follow the
+ * outpoint in a log line. One shape for all exclusions (contract gate, pending recovery, intent
+ * locks) so none can drop a coin silently while another logs.
  */
 type VtxoExclusion = (vtxo: ExcludableVtxo) => string | undefined;
 /**
- * The contract gate as an exclusion, naming why it closed: a handler ran and
- * declined, or this build has no handler for the type at all.
- *
- * The two want opposite reactions from whoever reads the log. A decline is
- * the gate working as designed — nothing to do. A missing handler means a
- * contract row this build cannot interpret, e.g. a vendoring or version
- * mismatch, which is worth a reader's attention. `contractHandlers` is
- * already available here, so the message can tell them apart instead of
- * collapsing both into one sentence that reads as the same case either way.
+ * The contract gate as an exclusion, distinguishing a handler's decline (working as designed)
+ * from a missing handler (a row this build can't interpret, e.g. a version mismatch, worth a
+ * reader's attention).
  */
 declare function gateExclusion(gated: GatedContracts): VtxoExclusion;
 /** Outpoints excluded for a shared reason, e.g. an intent-lock set. */
 declare function outpointExclusion(outpoints: ReadonlySet<string>, reason: string): VtxoExclusion;
 /**
- * Outpoints excluded for individually-named reasons — a per-input timelock,
- * where one shared reason would be wrong because the inputs differ.
- *
- * Unlike {@link gateExclusion}, the reasons are the handlers' own sentences and
- * are not rephrased to follow the outpoint: that text is what tells the reader
- * when to retry, and a paraphrase here would be a second spelling to keep in
- * step with it.
+ * Outpoints excluded for per-input reasons (e.g. a per-input timelock). The handlers' own
+ * sentences, unparaphrased: they tell the reader when to retry.
  *
  * @see outpointExclusion for the shared-reason form.
  */
 declare function outpointReasons(reasons: ReadonlyMap<string, string>): VtxoExclusion;
 /**
- * Report VTXOs an exclusion dropped — the only field-diagnosable signal for why
- * a coin is missing from a spend, or why an explicitly named one will fail.
- * Debug level, one line per VTXO per reason.
+ * Report VTXOs an exclusion dropped, the only field-diagnosable signal for a coin missing from a
+ * spend. Debug level, one line per VTXO per reason.
  */
 declare function logExcludedVtxos(source: string, vtxos: readonly ExcludableVtxo[], exclusions: readonly VtxoExclusion[]): void;
 /**
- * Thrown when a spend names VTXOs whose contract can no longer be annotated —
- * its handler is not registered here, its handler rejects the stored params, or
- * it has no contract row at all.
- *
- * Raised before submission on purpose. Spending reads the tapscripts stored on
- * each coin rather than re-deriving them, so such a spend would otherwise build
- * and broadcast normally and only fail in the bookkeeping afterwards, leaving
- * the transaction on the network and the local state behind it.
+ * Thrown before submission when a spend names VTXOs whose contract can no longer be annotated
+ * (handler unregistered, stored params rejected, or no row). Otherwise the spend would broadcast
+ * and fail in the bookkeeping, leaving local state behind the network.
  */
 declare class UnannotatableInputError extends Error {
     readonly name = "UnannotatableInputError";
 }
 
 /**
- * Encode a contract to the arkcontract string format.
- *
- * Format: arkcontract={type}&{key1}={value1}&{key2}={value2}...
- *
- * This format is compatible with NArk and allows contracts to be
- * shared/imported across different Arkade SDKs.
+ * Encode a contract to the arkcontract string format:
+ * `arkcontract={type}&{key1}={value1}&...`. NArk-compatible, so contracts can be shared
+ * across Arkade SDKs.
  *
  * @example
  * ```typescript
@@ -742,27 +596,18 @@ declare class UnannotatableInputError extends Error {
  */
 declare function encodeArkContract(contract: Contract): string;
 /**
- * Parsed result from decoding an arkcontract string.
- *
- * This is a low-level representation. For type-safe contract creation,
- * use `contractFromArkContract` or `contractFromArkContractWithAddress`
- * which validate params through the handler system.
+ * Raw (unvalidated) result of decoding an arkcontract string. For typed contracts use
+ * `contractFromArkContract` / `contractFromArkContractWithAddress`, which validate via handlers.
  */
 interface ParsedArkContract {
     /** Contract type (e.g., "vhtlc", "default") */
     type: string;
-    /** All key-value pairs from the string */
+    /** All other key-value pairs from the string */
     data: Record<string, string>;
 }
 /**
- * Decode an arkcontract string into raw type and data.
- *
- * This is a low-level function that parses the URL-encoded format.
- * For creating typed Contract objects, use `contractFromArkContract`
- * or `contractFromArkContractWithAddress` instead.
+ * Decode an arkcontract string into raw type and data (low-level; see {@link ParsedArkContract}).
  *
- * @param encoded - The arkcontract string
- * @returns Parsed type and key-value data
  * @throws If the string is not a valid arkcontract
  *
  * @example
@@ -773,14 +618,9 @@ interface ParsedArkContract {
  */
 declare function decodeArkContract(encoded: string): ParsedArkContract;
 /**
- * Create a Contract from an arkcontract string.
+ * Create a Contract (without script/address) from an arkcontract string.
  *
- * This requires a handler to be registered for the contract type.
- *
- * @param encoded - The arkcontract string
- * @param options - Additional options for the contract
- * @returns A Contract object
- * @throws If the string is invalid or no handler exists for the type
+ * @throws If the string is invalid or no handler is registered for the type
  *
  * @example
  * ```typescript
@@ -803,56 +643,26 @@ declare function contractFromArkContract(encoded: string, options?: {
 /**
  * Create a full Contract with derived script and address.
  *
- * @param encoded - The arkcontract string
  * @param serverPubKey - Server public key (for address derivation)
  * @param addressPrefix - Address prefix (e.g., "tark" for testnet)
- * @param options - Additional options
- * @returns A complete Contract object
  */
 declare function contractFromArkContractWithAddress(encoded: string, serverPubKey: Uint8Array, addressPrefix?: string, options?: {
     label?: string;
     state?: "active" | "inactive";
     metadata?: Record<string, unknown>;
 }): Contract;
-/**
- * Check if a string is an arkcontract.
- */
+/** Check if a string is an arkcontract. */
 declare function isArkContract(str: string): boolean;
 
-/**
- * Thrown when a descriptor-capable contract (default, delegate, or boarding)
- * cannot be routed to any signer: its owner key (`params.pubKey`) is not this
- * wallet's baseline signing key, and the record carries no
- * `metadata.signingDescriptor` to send it to a descriptor-aware signer.
- *
- * Note that this can arise also when a contract belongs to a different identity (storage reuse).
- */
-declare class MissingSigningDescriptorError extends Error {
-    readonly contractScript: string;
-    readonly contractType: "default" | "delegate" | "boarding";
-    readonly name = "MissingSigningDescriptorError";
-    constructor(contractScript: string, contractType: "default" | "delegate" | "boarding");
-}
-/**
- * Thrown when an input needs descriptor-aware signing but no
- * DescriptorProvider was wired into the wallet.
- */
-declare class DescriptorSigningProviderMissingError extends Error {
-    readonly name = "DescriptorSigningProviderMissingError";
-    constructor();
-}
-
 /**
  * In-memory implementation of ContractRepository.
  * Data is ephemeral and scoped to the instance.
  */
 declare class InMemoryContractRepository implements ContractRepository {
-    readonly version: 2;
-    private readonly contractData;
-    private readonly collections;
+    readonly version: 3;
     private readonly contractsByScript;
     clear(): Promise<void>;
-    getContracts(filter?: ContractFilter): Promise<Contract[]>;
+    getContractsPage(filter: ContractFilter | undefined, page: PageRequest): Promise<PageResult<Contract>>;
     saveContract(contract: Contract): Promise<void>;
     deleteContract(script: string): Promise<void>;
     [Symbol.asyncDispose](): Promise<void>;
@@ -864,44 +674,20 @@ declare class InMemoryContractRepository implements ContractRepository {
  * Data is stored as JSON strings in key/value stores.
  */
 declare class IndexedDBContractRepository implements ContractRepository {
-    readonly version: 2;
+    readonly version: 3;
     private readonly connection;
     constructor(dbName?: string);
     clear(): Promise<void>;
-    getContracts(filter?: ContractFilter): Promise<Contract[]>;
+    getContractsPage(filter: ContractFilter | undefined, page: PageRequest): Promise<PageResult<Contract>>;
     saveContract(contract: Contract): Promise<void>;
     deleteContract(script: string): Promise<void>;
+    /** Up to `limit + 1` rows of `range` that pass `filter`, in key order. */
+    private readMatching;
     private applyContractFilter;
     private getDB;
     [Symbol.asyncDispose](): Promise<void>;
 }
 
-/**
- * IndexedDB-based implementation of WalletRepository.
- */
-declare class IndexedDBWalletRepository implements WalletRepository {
-    readonly version: 1;
-    private readonly connection;
-    constructor(dbName?: string);
-    clear(): Promise<void>;
-    [Symbol.asyncDispose](): Promise<void>;
-    getVtxos(address: string): Promise<ExtendedVirtualCoin[]>;
-    saveVtxos(address: string, vtxos: ExtendedVirtualCoin[]): Promise<void>;
-    deleteVtxos(address: string): Promise<void>;
-    getVtxosForScript(script: string): Promise<ExtendedVirtualCoin[]>;
-    saveVtxosForScript(key: VtxoRepositoryKey, vtxos: ExtendedVirtualCoin[]): Promise<void>;
-    deleteVtxosForScript(script: string): Promise<void>;
-    getUtxos(address: string): Promise<ExtendedCoin[]>;
-    saveUtxos(address: string, utxos: ExtendedCoin[]): Promise<void>;
-    deleteUtxos(address: string): Promise<void>;
-    getTransactionHistory(address: string): Promise<ArkTransaction[]>;
-    saveTransactions(address: string, txs: ArkTransaction[]): Promise<void>;
-    deleteTransactions(address: string): Promise<void>;
-    getWalletState(): Promise<WalletState | null>;
-    saveWalletState(state: WalletState): Promise<void>;
-    private getDB;
-}
-
 interface WalletRestoreHook {
     id: string;
     restore(wallet: IWallet): Promise<void>;
@@ -909,43 +695,98 @@ interface WalletRestoreHook {
 declare function registerWalletRestoreHook(wallet: IWallet, hook: WalletRestoreHook): () => void;
 
 /**
- * Domain separator for the preimage derivation.
+ * In-memory single key implementation for Bitcoin transaction signing.
+ *
+ * @example
+ * ```typescript
+ * // Create from hex string
+ * const key = SingleKey.fromHex('your_private_key_hex');
  *
- * Protocol-scoped and versioned, mirroring NArk's `Arkade-Boltz-Preimage-v1`
- * (`SwapsManagementService.cs:128`), so any Arkade SDK implementing this
- * scheme reproduces the same preimage and can recover an artifact another
- * SDK created. Deliberately distinct from the Boltz tag: a shared tag would
- * make one wallet key derive one preimage for both corridors.
+ * // Create from raw bytes
+ * const key = SingleKey.fromPrivateKey(privateKeyBytes);
+ *
+ * // Create random key
+ * const randomKey = SingleKey.fromRandomBytes();
+ *
+ * // Sign a transaction
+ * const signedTx = await key.sign(transaction);
+ * ```
+ */
+declare class SingleKey implements Identity {
+    private key;
+    private constructor();
+    /** Create a signing identity from raw private key bytes. */
+    static fromPrivateKey(privateKey: Uint8Array): SingleKey;
+    /** Create a signing identity from a hex-encoded private key. */
+    static fromHex(privateKeyHex: string): SingleKey;
+    /** Create a signing identity with a freshly generated random private key. */
+    static fromRandomBytes(): SingleKey;
+    /**
+     * Export the private key as a hex string.
+     *
+     * @returns The private key as a hex string
+     */
+    toHex(): string;
+    sign(tx: Transaction, inputIndexes?: number[]): Promise<Transaction>;
+    compressedPublicKey(): Promise<Uint8Array>;
+    xOnlyPublicKey(): Promise<Uint8Array>;
+    signerSession(): SignerSession;
+    signMessage(message: Uint8Array, signatureType?: "schnorr" | "ecdsa"): Promise<Uint8Array>;
+    /**
+     * BIP-340 sign `messageHash` with aux_rand = 0, so the signature — and
+     * anything derived from it — is reproducible from the key alone.
+     *
+     * What lets a static wallet derive a swap preimage instead of storing one
+     * (see `wallet/contractSecrets.ts`). Deliberately NOT `signMessage`, whose
+     * schnorr branch draws a random aux_rand: a preimage derived from that is
+     * unrecoverable, and the loss would only surface at claim time.
+     */
+    signSchnorrDeterministic(messageHash: Uint8Array): Promise<Uint8Array>;
+    toReadonly(): Promise<ReadonlySingleKey>;
+}
+declare class ReadonlySingleKey implements ReadonlyIdentity {
+    private readonly publicKey;
+    /** Create a readonly identity from a compressed public key. */
+    constructor(publicKey: Uint8Array);
+    /**
+     * Create a ReadonlySingleKey from a compressed public key.
+     *
+     * @param publicKey - 33-byte compressed public key (02/03 prefix + 32-byte x coordinate)
+     * @returns A new ReadonlySingleKey instance
+     * @example
+     * ```typescript
+     * const pubkey = new Uint8Array(33); // your compressed public key
+     * const readonlyKey = ReadonlySingleKey.fromPublicKey(pubkey);
+     * ```
+     */
+    static fromPublicKey(publicKey: Uint8Array): ReadonlySingleKey;
+    xOnlyPublicKey(): Promise<Uint8Array>;
+    compressedPublicKey(): Promise<Uint8Array>;
+}
+
+/**
+ * Domain separator for the preimage derivation. Protocol-scoped and versioned, mirroring NArk's
+ * `Arkade-Boltz-Preimage-v1` (`SwapsManagementService.cs:128`), so any Arkade SDK reproduces the
+ * same preimage and can recover another SDK's artifact. Deliberately distinct from the Boltz tag:
+ * a shared tag would make one wallet key derive one preimage for both corridors.
  */
 declare const ARKADE_SWAP_PREIMAGE_TAG = "Arkade-RFQ-Preimage-v1";
 /**
- * Domain separator for the **salted** preimage derivation, used when the
- * descriptor repeats across artifacts.
- *
- * Corridor-generic where {@link ARKADE_SWAP_PREIMAGE_TAG} is not, and that
- * asymmetry is deliberate. The v1 tags must be per-corridor
- * (`Arkade-RFQ-Preimage-v1` here, NArk's `Arkade-Boltz-Preimage-v1` there)
- * because v1 pins its message index, so the tag is the only thing separating
- * two corridors that reach the same key. v2 mints a salt per artifact, so no
- * two artifacts share a message within a corridor, let alone across two — the
- * salt carries the separation, and the tag names the layer it belongs to.
+ * Domain separator for the **salted** derivation, used when the descriptor repeats across
+ * artifacts. Corridor-generic, unlike {@link ARKADE_SWAP_PREIMAGE_TAG}, deliberately: v1 pins its
+ * message index, so its tag is all that separates two corridors reaching the same key; here the
+ * per-artifact salt carries that separation.
  */
 declare const ARKADE_SALTED_PREIMAGE_TAG = "Arkade-Contract-Preimage-Salted-v1";
 /**
- * `TAG ‖ xonly(32) ‖ u32le(index)` — the message that gets BIP-340 signed.
- *
- * Anchored on the canonical x-only key rather than the descriptor string: a
- * restore reconstructs a bare descriptor that serialises differently from the
- * signing descriptor used at creation, and only the key agrees across both.
+ * `TAG ‖ xonly(32) ‖ u32le(index)` — the message that gets BIP-340 signed. Anchored on the x-only
+ * key, not the descriptor string: a restore rebuilds a descriptor that serialises differently from
+ * the one used at creation, and only the key agrees across both.
  */
 declare function buildPreimageMessage(xonly: Uint8Array, index: number): Uint8Array;
 /**
- * `TAG ‖ xonly(32) ‖ salt(32)` — the salted message that gets BIP-340 signed.
- *
- * The salt replaces v1's pinned index as the source of per-artifact
- * uniqueness, which is what lets a key that repeats across artifacts still
- * derive a distinct preimage for each. It is public: knowing it yields nothing
- * without the seed.
+ * `TAG ‖ xonly(32) ‖ salt(32)` — the salted message that gets BIP-340 signed. The salt replaces
+ * v1's pinned index as the per-artifact uniqueness source; it is public, useless without the seed.
  */
 declare function buildSaltedPreimageMessage(xonly: Uint8Array, salt: Uint8Array): Uint8Array;
 /**
@@ -964,18 +805,14 @@ interface ProvisionedKey {
      */
     descriptor: string;
     /**
-     * The Ark scriptPubKey that corresponds to this key — the pkScript of the
-     * wallet's current receive address. Returned alongside {@link pubkey} so
-     * callers building the lockup script do not need a separate
-     * {@link IWallet.getAddress} round-trip or an `ArkAddress.decode` call.
+     * The pkScript of the wallet's current receive address, so callers building the lockup need
+     * no separate {@link IWallet.getAddress} or `ArkAddress.decode`.
      */
     pkScript: Uint8Array;
     /**
-     * The receive address {@link pkScript} was decoded from, captured in the
-     * same single {@link IWallet.getAddress} read. The quote-time refund
-     * address and the covenant's `refundPkScript` must always name the same
-     * script, and two independent reads of a wallet that rotates its receive
-     * address would not guarantee that — reuse this, never a second
+     * The receive address {@link pkScript} was decoded from, in the same {@link IWallet.getAddress}
+     * read. The quote-time refund address and the covenant's `refundPkScript` must name the same
+     * script, and two reads of a rotating wallet need not agree — reuse this, never a second
      * `getAddress()` call.
      */
     address: string;
@@ -990,93 +827,61 @@ interface ProvisionedClaimSecret extends Omit<ProvisionedKey, "pkScript" | "addr
     /** `sha256(preimage)` — what the contract commits to. */
     paymentHash: Uint8Array;
     /**
-     * The salt {@link preimage} was derived from, when it came from the salted
-     * arm. **Public** — the opposite of {@link preimage} above: persist it with
-     * the artifact in the clear, because without it a wallet holding the seed
-     * still cannot re-derive P.
-     *
-     * Absent on the other two arms: an HD child descriptor already names one
-     * artifact, and a stored preimage needs no derivation input.
+     * The salt {@link preimage} was derived from, on the salted arm. **Public**, unlike
+     * {@link preimage}: persist it in the clear with the artifact — without it even the seed
+     * cannot re-derive P. Absent on the other arms.
      */
     preimageSalt?: Uint8Array;
     /**
-     * Persist `preimage` with the artifact: this wallet cannot re-derive it.
-     * True when the caller supplied P, or when the signer cannot sign
-     * deterministically. When false the preimage re-derives from the seed —
-     * given {@link preimageSalt}, where there is one — and nothing secret
-     * needs to be stored.
+     * Persist `preimage` with the artifact: this wallet cannot re-derive it (caller-supplied P,
+     * or a signer that cannot sign deterministically). When false, P re-derives from the seed
+     * (given {@link preimageSalt}, if any) and nothing secret needs storing.
      */
     mustPersistPreimage: boolean;
 }
 /**
- * The key that spends a leg we fund — the refund key of an HTLC, the user key
- * of a covenant's cancel path.
+ * The key that spends a leg we fund — an HTLC's refund key, a covenant's cancel-path user key.
  *
- * The returned `pubkey` is taken from a signer the wallet produced, never
- * from the descriptor string alone. That is the difference between an
- * invariant and a comment: deriving the leaf key is pure parsing and would
- * succeed just as well for a key this wallet cannot sign for — a descriptor
- * allocated by a worker rebound to another identity, a record restored onto
- * the wrong seed — and the covenant would bind it, the leg would fund, and
- * the failure would surface at refund time with the money already committed.
- * Throws {@link ForeignDescriptorError} instead, before there is a quote.
+ * `pubkey` comes from a signer the wallet produced, never the descriptor string alone: parsing
+ * succeeds just as well for a key this wallet cannot sign for (a worker rebound to another
+ * identity, a record restored onto the wrong seed), and the failure would surface at refund time
+ * with the money committed. Throws {@link ForeignDescriptorError} instead, before any quote.
  *
- * The wallet's identity key is reused rather than a fresh HD child, so no
- * index is consumed when the artifact is never built — and the covenant's
- * refund path is on the same key as the refund address the caller sends to
- * at quote time.
+ * Reuses the identity key rather than a fresh HD child, so no index is consumed for an artifact
+ * never built, and the refund path is on the same key as the quote-time refund address.
  */
 declare function provisionRefundKey(wallet: IWallet): Promise<ProvisionedKey>;
 /**
- * The key that spends a leg we claim, plus the preimage that unlocks it.
- *
- * Pass `opts.preimage` to bring your own 32-byte P; it comes back verbatim
- * with `mustPersistPreimage` set, since the wallet cannot re-derive what it
- * did not choose.
+ * The key that spends a leg we claim, plus the preimage that unlocks it. Three arms:
  *
- * Three arms, and which one a wallet lands in is the whole of this function:
- *
- * 1. **Caller-supplied P.** Returned unchanged, `mustPersistPreimage: true`.
- * 2. **Per-artifact descriptor** (an HD child). Derives from the key alone at
- *    the pinned index. Nothing at rest. Raises rather than falling through if
- *    the signer cannot sign deterministically — an HD descriptor whose wallet
- *    refuses is a broken wallet, not a fallback case.
- * 3. **Anything else** — a static wallet's `tr(pubkey)`, or a constant
- *    descriptor from a custom provider. Mints a public per-artifact salt and
- *    derives from it, so a key that repeats still yields a distinct P. Only
- *    this arm falls back to a stored random preimage, and only when the signer
- *    refuses — which is discovered by deriving, never by probing.
+ * 1. **Caller-supplied `opts.preimage`** (32 bytes). Returned verbatim with
+ *    `mustPersistPreimage: true`, since the wallet cannot re-derive what it did not choose.
+ * 2. **Per-artifact descriptor** (an HD child). Derives from the key alone at the pinned index;
+ *    nothing at rest. Raises if the signer cannot sign deterministically — that is a broken HD
+ *    wallet, not a fallback case.
+ * 3. **Anything else** (a static `tr(pubkey)`, a custom provider's constant descriptor). Mints a
+ *    public per-artifact salt and derives from it. Only this arm falls back to a stored random
+ *    preimage, and only when the signer refuses — discovered by deriving, never by probing.
  */
 declare function provisionClaimSecret(wallet: IWallet, opts?: {
     preimage?: Uint8Array;
 }): Promise<ProvisionedClaimSecret>;
 /**
- * The signer for a provisioned descriptor, verified to actually be that
- * descriptor's key.
- *
- * The verification is a public-key equality, never a wallet-type probe: a
- * wallet that answers with the wrong key — another seed's, after a restore
- * mix-up — would sign happily, and the failure would surface only as a
- * counterparty rejection or a dead script.
+ * The signer for a provisioned descriptor, verified by public-key equality (never a wallet-type
+ * probe) to be that descriptor's key: a wallet answering with another seed's key would sign
+ * happily and fail only as a counterparty rejection or a dead script.
  *
- * Know its limit. It catches a wallet that substitutes its *baseline*
- * identity, which is the failure this exists for. It cannot catch one that
- * returns a descriptor-scoped identity built over the same descriptor, since
- * such an identity reads its pubkey back out of the descriptor string and the
- * comparison becomes a tautology. What rules that case out is
- * {@link resolveDescriptorSigner}'s `isOurs` test, which both shipped wallets
- * resolve through — so this is the backstop for a hand-rolled `IWallet`, not
- * the primary guarantee.
+ * Limit: this catches a wallet substituting its *baseline* identity. A descriptor-scoped identity
+ * over the same descriptor reads its pubkey back from the string, making the check a tautology;
+ * {@link resolveDescriptorSigner}'s `isOurs` test (used by both shipped wallets) rules that out,
+ * so this is the backstop for a hand-rolled `IWallet`, not the primary guarantee.
  */
 declare function contractSigner(wallet: IWallet, descriptor: string): Promise<Identity>;
 /**
- * A wallet that holds a contract's key but cannot sign with it: a watch-only
- * identity, or a remote signer whose transport is absent.
- *
- * Distinct from {@link ForeignDescriptorError} because the remedy differs —
- * that one says "wrong wallet", this one says "this wallet, without its
- * signer". Raised at provisioning as well as at signing, so a wallet that
- * could never spend the leg finds out before it funds one.
+ * A wallet that holds a contract's key but cannot sign with it (watch-only, or a remote signer
+ * without its transport). Distinct from {@link ForeignDescriptorError} ("wrong wallet") because
+ * the remedy differs. Raised at provisioning too, so a wallet that could never spend a leg finds
+ * out before funding it.
  */
 declare class WalletCannotSignError extends Error {
     readonly descriptor: string;
@@ -1084,18 +889,12 @@ declare class WalletCannotSignError extends Error {
     constructor(descriptor: string);
 }
 /**
- * The preimage for a provisioned descriptor: `opts.stored` when the artifact
- * kept one, otherwise re-derived from the seed.
+ * The preimage for a provisioned descriptor, in the precedence {@link provisionClaimSecret} chose:
  *
- * Resolves in one precedence order, mirroring the arms
- * {@link provisionClaimSecret} chose between:
- *
- * 1. `opts.stored` — a caller-supplied P, or one from a wallet that could not
- *    derive. Whatever the wallet can do now, a stored P is the artifact's.
+ * 1. `opts.stored` — a caller-supplied P, or one a wallet could not derive; always the artifact's.
  * 2. a per-artifact descriptor — derive at the pinned index.
  * 3. `opts.salt` — derive from the salted message.
- * 4. otherwise throw: a repeating descriptor with neither a stored preimage
- *    nor a salt has nothing to derive from that would not collide.
+ * 4. otherwise throw: a repeating descriptor with neither has nothing collision-free to derive.
  */
 declare function contractPreimage(wallet: IWallet, descriptor: string, opts?: {
     stored?: Uint8Array;
@@ -1106,33 +905,47 @@ declare function contractPreimage(wallet: IWallet, descriptor: string, opts?: {
  * rather than degrading to a random-aux signer. */
 interface DeterministicSigner extends ReadonlyIdentity {
     /**
-     * Implementors wrapping a remote: throw only for a refusal that will
-     * repeat. {@link provisionClaimSecret} reads a transient throw — a network
-     * hiccup, an extension timeout — as "this signer cannot derive", and falls
-     * back to a stored random preimage for the artifact's whole life. That is
-     * claimable, but it persists a secret the seed would otherwise have
-     * replaced, and nothing surfaces the downgrade to the caller.
+     * Implementors wrapping a remote: throw only for a refusal that will repeat.
+     * {@link provisionClaimSecret} reads any throw (even a network hiccup) as "cannot derive" and
+     * silently falls back to a stored random preimage for the artifact's whole life.
      */
     signSchnorrDeterministic(messageHash: Uint8Array): Promise<Uint8Array>;
 }
 declare function isDeterministicSigner(value: unknown): value is DeterministicSigner;
 /**
- * Claim a restored artifact's index so a later allocation cannot reissue it —
- * which would derive that artifact's preimage a second time, for a different
- * one.
- *
- * Monotonic, and a no-op wherever there is no index to reserve — a shared-key
- * descriptor, or another seed's artifact. Restores iterate whole histories, so
- * an artifact this wallet has nothing to adopt for must not abort the loop.
+ * Claim a restored artifact's index so a later allocation cannot reissue it (which would derive
+ * that artifact's preimage again, for a different one).
  *
- * Telling "another seed's" apart from a failure needs
- * {@link HDWalletCapable.signerForDescriptor}, so an allocation-capable wallet
- * that does not also implement it gets only the watermark call's own untyped
- * refusal, and a foreign artifact reaches the caller as an error rather than a
- * skip. Every wallet shipped here implements both.
+ * Monotonic, and a no-op wherever there is no index to reserve (a shared-key descriptor, another
+ * seed's artifact), since restores iterate whole histories. Recognising "another seed's" needs
+ * {@link HDWalletCapable.signerForDescriptor}; without it a foreign artifact surfaces as the
+ * watermark call's untyped error. Every shipped wallet implements both.
  */
 declare function adoptContractDescriptor(wallet: IWallet, descriptor: string): Promise<void>;
 
+/**
+ * Thrown when a descriptor-capable contract (default, delegate, or boarding)
+ * cannot be routed to any signer: its owner key (`params.pubKey`) is not this
+ * wallet's baseline signing key, and the record carries no
+ * `metadata.signingDescriptor` to send it to a descriptor-aware signer.
+ *
+ * Note that this can arise also when a contract belongs to a different identity (storage reuse).
+ */
+declare class MissingSigningDescriptorError extends Error {
+    readonly contractScript: string;
+    readonly contractType: "default" | "delegate" | "boarding";
+    readonly name = "MissingSigningDescriptorError";
+    constructor(contractScript: string, contractType: "default" | "delegate" | "boarding");
+}
+/**
+ * Thrown when an input needs descriptor-aware signing but no
+ * DescriptorProvider was wired into the wallet.
+ */
+declare class DescriptorSigningProviderMissingError extends Error {
+    readonly name = "DescriptorSigningProviderMissingError";
+    constructor();
+}
+
 type RequestEnvelope = {
     tag: string;
     id: string;
@@ -1154,6 +967,11 @@ type ResponseEnvelope = {
     errorName?: string;
     broadcast?: boolean;
 };
+type MessageBusServices = {
+    arkProvider: ArkProvider;
+    wallet?: Wallet;
+    readonlyWallet: ReadonlyWallet;
+};
 interface MessageHandler<REQ extends RequestEnvelope = RequestEnvelope, RES extends ResponseEnvelope = ResponseEnvelope> {
     /**
      * A unique identifier for the updater.
@@ -1170,11 +988,7 @@ interface MessageHandler<REQ extends RequestEnvelope = RequestEnvelope, RES exte
      * bus re-init or `stop()` it goes inert on its own, so retaining one past
      * `stop()` cannot post.
      **/
-    start(services: {
-        arkProvider: ArkProvider;
-        wallet?: Wallet;
-        readonlyWallet: ReadonlyWallet;
-    }, repositories: {
+    start(services: MessageBusServices, repositories: {
         walletRepository: WalletRepository;
     }, channel?: {
         broadcast(response: RES): void;
@@ -1220,17 +1034,19 @@ type Options = {
      * `storage.intentRepository`. Same opt-in as a main-thread wallet: without
      * it the worker persists no settlement intent, reconciles none on restart,
      * and counts intent-locked VTXOs as available. Pass the same repository the
-     * main thread uses so both sides read one intent state.
+     * main thread uses so both sides read one intent state, but settle from one
+     * side only: reconciliation deletes from the server any pending intent the
+     * worker's wallet is not settling itself.
      *
      * Ignored when `buildServices` is supplied — that override owns `storage`.
      */
     intentRepository?: IntentRepository;
+    /** The worker wallet's onchain provider, per network: an instance cannot cross `postMessage`.
+     * Called on every init and never closed, so return one instance per network. Defaults to
+     * Esplora; ignored when `buildServices` is supplied. */
+    onchainProvider?: (network: NetworkName) => OnchainProvider;
     debug?: boolean;
-    buildServices?: (config: Initialize["config"]) => Promise<{
-        arkProvider: ArkProvider;
-        wallet?: Wallet;
-        readonlyWallet: ReadonlyWallet;
-    }>;
+    buildServices?: (config: Initialize["config"]) => Promise<MessageBusServices>;
 };
 type Initialize = {
     type: "INITIALIZE_MESSAGE_BUS";
@@ -1243,14 +1059,15 @@ type Initialize = {
         };
         delegateUrl?: string;
         settlementConfig?: SettlementConfig | false;
+        /** @see WalletConfig.concurrentSpending */
+        concurrentSpending?: boolean;
         walletMode?: "auto" | "static" | "hd";
+        lazyInitialization?: boolean;
         watcherConfig?: Partial<Omit<ContractWatcherConfig, "indexerProvider">>;
         /** @see WalletConfig.lookAheadWindow */
         lookAheadWindow?: number;
         /** @see WalletConfig.minBatchExpirySeconds */
         minBatchExpirySeconds?: bigint;
-        /** @see WalletConfig.minCheckpointExitDelaySeconds */
-        minCheckpointExitDelaySeconds?: bigint;
         /**
          * Page-supplied per-operation timeout map. Keys are message types
          * (e.g. "SETTLE"). Overrides constructor-supplied
@@ -1286,13 +1103,14 @@ declare class MessageBus {
     private readonly buildServicesFn;
     private readonly boundOnMessage;
     private readonly intentRepository?;
+    private readonly onchainProvider?;
     /** Pending broadcasts, drained FIFO by a single {@link drain} loop. */
     private broadcastQueue;
     private draining;
     /** Bumped wherever the generation owning the queued broadcasts ends. */
     private broadcastEpoch;
     /** Create the service-worker message bus with repositories and handler configuration. */
-    constructor(walletRepository: WalletRepository, contractRepository: ContractRepository, { messageHandlers, tickIntervalMs, messageTimeoutMs, messageTimeoutOverrides, intentRepository, debug, buildServices, }: Options);
+    constructor(walletRepository: WalletRepository, contractRepository: ContractRepository, { messageHandlers, tickIntervalMs, messageTimeoutMs, messageTimeoutOverrides, intentRepository, onchainProvider, debug, buildServices, }: Options);
     /** Start the message bus and attach service-worker event listeners. */
     start(): Promise<void>;
     /** Stop the message bus, cancel ticks, and stop all registered handlers. */
@@ -1387,51 +1205,22 @@ declare class MessageBus {
     static setup(path: string): Promise<ServiceWorker>;
 }
 
-/**
- * A leaf node in the Taproot script tree, as consumed by
- * `@scure/btc-signer`'s `p2tr(internalKey, tree, ...)`.
- */
+/** A leaf node in the Taproot script tree, as consumed by `@scure/btc-signer`'s `p2tr`. */
 interface TaprootLeaf {
     script: Bytes;
     leafVersion: number;
 }
-/**
- * Internal tree node shape consumed by `@scure/btc-signer`'s `p2tr`:
- *   - A leaf is `{ script, leafVersion }`
- *   - A branch is a 2-element tuple `[leftNode, rightNode]` of nodes
- */
+/** A `p2tr` tree node: a leaf, or a `[left, right]` branch tuple. */
 type TaprootTreeNode = TaprootLeaf | [TaprootTreeNode, TaprootTreeNode];
 /**
- * Assemble a Taproot script tree from a flat list of scripts using the
- * exact algorithm arkd's btcd dependency uses
- * (`txscript.AssembleTaprootScriptTree`, see
- * https://github.com/btcsuite/btcd/blob/master/txscript/taproot.go).
- *
- * The algorithm:
- *
- *   Phase 1 — pair leaves left-to-right:
- *     for i := 0; i < len(leaves); i += 2:
- *       if i is the last index (odd leaf at end):
- *         merge with the LAST branch built so far (do NOT pair as a fresh leaf)
- *       else:
- *         create a new branch from (leaves[i], leaves[i+1])
+ * Assemble a Taproot script tree with btcd's `txscript.AssembleTaprootScriptTree` algorithm
+ * (the one arkd uses).
  *
- *   Phase 2 — FIFO-queue merge branches:
- *     while branches has ≥ 2 items:
- *       take front two, combine into a new branch, push to back of queue
+ * `@scure/btc-signer`'s `taprootListToTree` builds a Huffman tree instead; the two agree only for
+ * power-of-2 leaf counts. Any other count yields a different merkle root → different output key
+ * → arkd rejects spends with `INVALID_PSBT_INPUT`.
  *
- * This matters because `@scure/btc-signer`'s `taprootListToTree` builds a
- * Huffman tree (weight-1 leaves combine by smallest-weight pairs). For
- * power-of-2 leaf counts both algorithms happen to produce the same
- * perfectly-balanced binary tree and agree. For any other count they
- * produce DIFFERENT shapes → different merkle roots → different taproot
- * output keys → arkd rejects spends with `INVALID_PSBT_INPUT`.
- *
- * Reproducing btcd's algorithm here lets the SDK construct taptrees that
- * arkd accepts for arbitrary leaf counts.
- *
- * @param scripts - Raw tapscript bytes for each leaf, in the order they
- *                  should be encoded in the TapTree PSBT field.
+ * @param scripts - Raw tapscript bytes per leaf, in TapTree PSBT field order.
  * @returns The nested-tuple form `p2tr` accepts.
  */
 declare function assembleBtcdTaprootTree(scripts: Bytes[]): TaprootTreeNode;
@@ -1492,11 +1281,10 @@ declare class AssetId {
     readonly groupIndex: number;
     private constructor();
     /**
-     * Create an asset id from a genesis transaction id and group index.
+     * Create a validated asset id from a genesis transaction id and group index.
      *
      * @param txid - Hex-encoded genesis transaction id
      * @param groupIndex - Asset group index within the genesis transaction
-     * @returns A validated asset id
      * @throws Error if the txid is missing, malformed, or not 32 bytes long
      * @see fromString
      */
@@ -1504,8 +1292,6 @@ declare class AssetId {
     /**
      * Decode an asset id from its hex string representation.
      *
-     * @param s - Hex-encoded asset id
-     * @returns Decoded asset id
      * @throws Error if the string is not valid hex or does not encode a valid asset id
      * @see toString
      */
@@ -1513,22 +1299,18 @@ declare class AssetId {
     /**
      * Decode an asset id from its serialized bytes.
      *
-     * @param buf - Serialized asset id bytes
-     * @returns Decoded asset id
      * @throws Error if the buffer length is invalid
      */
     static fromBytes(buf: Uint8Array): AssetId;
     /**
      * Serialize the asset id to raw bytes.
      *
-     * @returns Serialized asset id bytes
      * @see fromBytes
      */
     serialize(): Uint8Array;
     /**
      * Encode the asset id to a hex string.
      *
-     * @returns Hex-encoded asset id
      * @see fromString
      */
     toString(): string;
@@ -1539,17 +1321,14 @@ declare class AssetId {
      */
     validate(): void;
     /**
-     * Decode an asset id from a binary reader.
+     * Decode an asset id from a binary reader positioned at one.
      *
-     * @param reader - Reader positioned at an asset id
-     * @returns Decoded asset id
      * @throws Error if the reader does not contain enough bytes
      */
     static fromReader(reader: BufferReader): AssetId;
     /**
      * Serialize the asset id into an existing binary writer.
      *
-     * @param writer - Writer to append the asset id to
      * @see serialize
      */
     serializeTo(writer: BufferWriter): void;
@@ -1579,27 +1358,18 @@ declare class AssetRef {
     private constructor();
     /** Reference type discriminator. */
     get type(): AssetRefType;
-    /**
-     * Create an asset reference that points to a specific asset id.
-     *
-     * @param assetId - Asset id referenced by this pointer
-     * @returns Asset reference by id
-     * @see fromGroupIndex
-     */
+    /** Reference a specific asset id. @see fromGroupIndex */
     static fromId(assetId: AssetId): AssetRef;
     /**
-     * Create an asset reference that points to another asset group by index.
+     * Reference another asset group in the packet.
      *
      * @param groupIndex - Zero-based asset group index in the packet
-     * @returns Asset reference by group index
      * @see fromId
      */
     static fromGroupIndex(groupIndex: number): AssetRef;
     /**
-     * Decode an asset reference from its hex string form.
+     * Decode an asset reference from hex.
      *
-     * @param s - Hex-encoded asset reference
-     * @returns Decoded asset reference
      * @throws Error if the string is not valid hex or does not encode a valid asset reference
      * @see toString
      */
@@ -1607,39 +1377,20 @@ declare class AssetRef {
     /**
      * Decode an asset reference from its serialized bytes.
      *
-     * @param buf - Serialized asset reference bytes
-     * @returns Decoded asset reference
      * @throws Error if the buffer is empty or malformed
      */
     static fromBytes(buf: Uint8Array): AssetRef;
-    /**
-     * Serialize the asset reference to raw bytes.
-     *
-     * @returns Serialized asset reference bytes
-     * @see fromBytes
-     */
+    /** Serialize to raw bytes. @see fromBytes */
     serialize(): Uint8Array;
-    /**
-     * Encode the asset reference to a hex string.
-     *
-     * @returns Hex-encoded asset reference
-     * @see fromString
-     */
+    /** Encode to hex. @see fromString */
     toString(): string;
     /**
-     * Decode an asset reference from a binary reader.
+     * Decode an asset reference from a reader positioned at one.
      *
-     * @param reader - Reader positioned at an asset reference
-     * @returns Decoded asset reference
      * @throws Error if the type is unknown or the reader does not contain enough bytes
      */
     static fromReader(reader: BufferReader): AssetRef;
-    /**
-     * Serialize the asset reference into an existing binary writer.
-     *
-     * @param writer - Writer to append the asset reference to
-     * @see serialize
-     */
+    /** Append the serialized reference to `writer`. @see serialize */
     serializeTo(writer: BufferWriter): void;
 }
 
@@ -1993,15 +1744,9 @@ declare class Packet implements ExtensionPacket {
  * Shipped from `src/` rather than `test/` so consumers outside this package can
  * pin the same bytes: `lightning-swap-service` imports this value, while NArk
  * and go-sdk vendor the backing `assetIdVectors.json` from a pinned revision of
- * this repository.
- *
- * The encoding is implemented in seven places across three repos and every
- * disagreement between them fails silently — a flipped txid makes a covenant
- * unsatisfiable, a flipped group index resolves to a different asset, a case
- * mismatch is a routing miss. None of those name their cause, which is what
- * these vectors are for.
- *
- * @see plans/asset-id-shared-vectors.md
+ * this repository. The encoding is implemented in seven places across three
+ * repos, and every disagreement fails silently (a flipped txid makes a covenant
+ * unsatisfiable, a flipped group index resolves to a different asset).
  */
 interface AssetIdVectors {
     readonly version: number;
@@ -2051,9 +1796,8 @@ interface AssetIdVectors {
  * The asset-id test vectors, deeply frozen.
  *
  * @remarks
- * Frozen all the way down, not just at the top: every value that matters lives
- * inside the nested arrays, and the module is a singleton — one consumer
- * mutating an entry would corrupt it for every other consumer in the process.
+ * Frozen all the way down: the module is a singleton, and one consumer mutating
+ * a nested entry would corrupt it for every other consumer in the process.
  *
  * @example
  * ```typescript
@@ -2123,6 +1867,13 @@ declare class DustChangeError extends Error {
     readonly dustAmount: bigint;
     constructor(change: bigint, dustAmount: bigint);
 }
+/** Thrown when a collaborative exit's change VTXO is above the server's
+ *  per-output ceiling, which arkd answers with `AMOUNT_TOO_HIGH`. */
+declare class OversizedChangeError extends Error {
+    readonly change: bigint;
+    readonly maxAmount: bigint;
+    constructor(change: bigint, maxAmount: bigint);
+}
 /**
  * Ramps is a class wrapping `settle` method to provide a more convenient interface for onboarding and offboarding operations.
  *
@@ -2172,6 +1923,10 @@ declare class Ramps {
      * @param feeInfo - The fee info to deduct from the offboard amount.
      * @param amount - The amount to offboard. If not provided, the total amount of virtual outputs will be offboarded.
      * @param eventCallback - Optional callback that receives settlement events
+     * @param vtxos - Specific virtual outputs to spend, mirroring {@link onboard}'s
+     * `boardingUtxos`. Omitted, every spendable one is spent — merging the whole
+     * off-chain balance into a single change output. Taken as given like
+     * `settle({ inputs })`: an `amount` these cannot cover is an error, not a top-up.
      * @returns The Arkade transaction id created by settlement
      * @throws Error if no virtual outputs remain after fee deduction or the destination address cannot be decoded
      * @see IWallet.getSpendableVtxos
@@ -2183,26 +1938,39 @@ declare class Ramps {
      * await ramps.offboard('bc1q...', feeInfo);
      * ```
      */
-    offboard(destinationAddress: string, feeInfo: FeeInfo, amount?: bigint, eventCallback?: (event: SettlementEvent) => void): ReturnType<IWallet["settle"]>;
+    offboard(destinationAddress: string, feeInfo: FeeInfo, amount?: bigint, eventCallback?: (event: SettlementEvent) => void, vtxos?: NormalizedExtendedVirtualCoin[]): ReturnType<IWallet["settle"]>;
+    /**
+     * Collaboratively exit with the DESTINATION paid exactly `amount`, pricing the
+     * fee on that output rather than on a grossed-up figure. {@link offboard} keeps
+     * the other anchor, which needs `g - fee(g) = amount` solved — impossible for
+     * a program charging the whole output.
+     */
+    offboardExact(params: {
+        destinationAddress: string;
+        feeInfo: FeeInfo;
+        /** Sats the destination receives, exactly. */
+        amount: bigint;
+        eventCallback?: (event: SettlementEvent) => void;
+        vtxos?: NormalizedExtendedVirtualCoin[];
+    }): ReturnType<IWallet["settle"]>;
+    private offboardInputs;
+    /** Every candidate, or with `concurrentSpending` the shortest covering prefix in send order. */
+    private fundExit;
+    /** Re-runs an SDK-picked exit that lost a coin to a concurrent spend. */
+    private withRepick;
+    /** Fund the change output: pay its own fee, then judge it against both
+     *  server-side bounds. `0n` in is `0n` out — no change output at all. */
+    private fundChange;
 }
 
 /**
- * HD-wallet {@link DescriptorProvider} that allocates a fresh signing
- * descriptor on every call. The provider holds no notion of "current" — it
- * is a pure rotating allocator. The question of "which descriptor is the
- * wallet currently bound to?" is answered by querying the contract
- * repository for active contracts, not by asking this provider.
+ * HD-wallet {@link DescriptorProvider} that allocates a fresh signing descriptor on every call.
+ * A pure rotating allocator: which descriptor the wallet is bound to is answered by the contract
+ * repository, not this provider.
  *
- * State is persisted under `WalletRepository.getWalletState().settings.hd` so
- * that no storage-schema migration is required when switching a wallet from
- * single-key to HD. The provider is backed by an {@link HDCapableIdentity},
- * which carries the wildcard account descriptor template (for derivation)
- * and the signing primitives.
- *
- * The read-modify-write of the persisted index runs inside the shared per-
- * repo `updateWalletState` mutex, so two `getNextSigningDescriptor` callers
- * — including those driving separate `HDDescriptorProvider` instances on
- * the same repo — can never observe the same index.
+ * State lives in `settings.hd` of the wallet state, so switching single-key → HD needs no schema
+ * migration. Allocation runs inside the shared per-repo `updateWalletState` mutex, so callers
+ * (even on separate instances over one repo) never observe the same index.
  *
  * @example
  * ```ts
@@ -2218,104 +1986,50 @@ declare class HDDescriptorProvider implements DescriptorProvider, ReceiveRotator
     private readonly walletRepository;
     private constructor();
     /**
-     * Construct an HDDescriptorProvider. No I/O is performed here;
-     * persisted state is read lazily on the first call to
-     * `getNextSigningDescriptor`. A descriptor-mismatch error surfaces on
-     * first use rather than at boot.
+     * Construct an HDDescriptorProvider. No I/O: state is read lazily, so a descriptor-mismatch
+     * error surfaces on first use rather than here.
      */
     static create(identity: HDCapableIdentity, walletRepository: WalletRepository): Promise<HDDescriptorProvider>;
-    /**
-     * Allocate the next descriptor and return it. The first call on a fresh
-     * wallet returns descriptor at index 0; subsequent calls return 1, 2, 3,
-     * ... in order. Each call is atomic with respect to other rotations on
-     * the same repo: two concurrent callers can never observe the same
-     * index.
-     */
+    /** Allocate and return the next descriptor (index 0, 1, 2, …), atomically per repo. */
     getNextSigningDescriptor(): Promise<string>;
     /**
-     * Re-derive the descriptor at the most recently allocated index
-     * WITHOUT advancing — i.e. read the same descriptor
-     * `getNextSigningDescriptor` last returned. Returns `undefined`
-     * when no descriptor has ever been allocated on this repo.
-     *
-     * Used by the boot path to keep the wallet's display address
-     * stable across restarts: when no tagged display contract exists
-     * (e.g. a fresh wallet that hasn't rotated yet, or a wallet whose
-     * baseline-only repo carries no rotation history), the boot should
-     * re-derive the existing index rather than burn a new one.
+     * Re-derive the descriptor `getNextSigningDescriptor` last returned, WITHOUT advancing;
+     * `undefined` if none was ever allocated. Lets boot keep the display address stable across
+     * restarts when no tagged display contract exists, instead of burning a new index.
      */
     getCurrentSigningDescriptor(): Promise<string | undefined>;
-    /**
-     * The most recently allocated index, or `undefined` when nothing has ever
-     * been allocated on this repo. Read-only peek at the watermark that
-     * {@link getNextSigningDescriptor} advances.
-     */
+    /** Read-only peek at the allocation watermark; `undefined` if nothing was ever allocated. */
     getLastIndexUsed(): Promise<number | undefined>;
     /**
-     * Monotonically advance the allocation watermark so the next
-     * `getNextSigningDescriptor()` skips indices discovered by a restore
-     * scan. Never rewinds: a lower or equal `index` is a no-op.
-     *
-     * An invalid `index` (non-integer / negative / past the BIP32
-     * non-hardened ceiling) is ignored (no-op): persisting it would corrupt
-     * `lastIndexUsed` and make the next `parseSettings()` throw, mirroring
-     * the validation parseSettings already enforces. The upper bound matters
-     * because the damage outlives the call — `materializeDescriptorAt` cannot
-     * derive at or above 2^31, so a watermark parked there would fail every
-     * subsequent allocation for the life of the repo.
+     * Monotonically advance the watermark past indices found by a restore scan; never rewinds.
+     * An invalid `index` (non-integer, negative, or >= 2^31) is ignored: persisting it would make
+     * `parseSettings()` throw, and a watermark at the hardened ceiling would fail every later
+     * allocation for the life of the repo.
      */
     advanceLastIndexUsed(index: number): Promise<void>;
-    /**
-     * Returns true when the given descriptor is derivable from this wallet's
-     * seed. Delegates to the underlying identity, which handles both HD and
-     * simple `tr(pubkey)` descriptors.
-     */
+    /** Whether `descriptor` (HD or simple `tr(pubkey)`) is derivable from this wallet's seed. */
     isOurs(descriptor: string): boolean;
-    /**
-     * Signs each request with the key derived from its descriptor. Delegates
-     * to the identity's signing primitives — the identity, not the provider,
-     * holds the seed.
-     */
+    /** Signs each request with its descriptor's derived key (the identity holds the seed). */
     signWithDescriptor(requests: DescriptorSigningRequest[]): Promise<Transaction[]>;
     /** Signs a message using the key derived from `descriptor`. */
     signMessageWithDescriptor(descriptor: string, message: Uint8Array, signatureType?: "schnorr" | "ecdsa"): Promise<Uint8Array>;
-    /**
-     * HD providers participate in receive rotation. The default
-     * factory boot (contract-repo lookup → allocate fresh descriptor)
-     * is exactly what we want, so this just delegates to
-     * {@link WalletReceiveRotator.defaultBoot}.
-     */
+    /** HD providers take part in receive rotation via {@link WalletReceiveRotator.defaultBoot}. */
     createReceiveRotator(opts: ReceiveRotatorBootOpts): Promise<ReceiveRotatorBoot | undefined>;
     /**
-     * Substitute the wildcard in the identity's account-descriptor template
-     * with a concrete index, going through the descriptors-scure parser
-     * rather than ad-hoc string substitution. The parser's `expand({ index })`
-     * call validates that the input is a ranged template AND produces a
-     * canonical materialized key expression at the given index.
-     *
-     * This is a pure read: it does NOT advance the allocation watermark.
-     * Used by restore's gap-scan to peek descriptors at arbitrary indices
-     * without side-effects.
+     * Materialize the account template at `index` via the descriptors-scure parser (validates the
+     * ranged template and yields a canonical key expression) rather than string substitution.
+     * Pure: does NOT advance the watermark, so restore's gap-scan can peek arbitrary indices.
      */
     materializeDescriptorAt(index: number): string;
     /**
-     * Run the read-modify-write of HD settings inside the shared per-repo
-     * wallet-state mutex. The closure receives a freshly-validated settings
-     * snapshot, mutates it, and returns whatever value the caller wants to
-     * surface; the mutated settings are then persisted as part of the same
-     * atomic update.
-     *
-     * Doing the read inside the lock is what prevents two providers (or two
-     * concurrent callers on the same provider) from racing on a stale index.
+     * Read-modify-write HD settings inside the shared per-repo wallet-state mutex; `fn` mutates a
+     * validated snapshot that is persisted atomically. Reading inside the lock prevents races on a
+     * stale index.
      */
     private mutate;
     /**
-     * Validate the persisted HD settings (or initialize a fresh record when
-     * absent) and return a clone safe for the caller to mutate.
-     *
-     * The cast to `HDWalletSettings` trusts storage; a corrupted or
-     * partially-migrated repo could otherwise produce `NaN` descriptors.
-     * Fail loud rather than silently derive garbage.
+     * Validate persisted HD settings (or init a fresh record) and return a mutable clone. Fails
+     * loud: a corrupt repo would otherwise derive `NaN` descriptors.
      */
     private parseSettings;
 }
@@ -2334,6 +2048,7 @@ type RequestInitWallet = RequestEnvelope & {
     payload: {
         arkServerUrl: string;
         arkServerPublicKey?: string;
+        lazyBoarding?: boolean;
     };
 };
 type ResponseInitWallet = ResponseEnvelope & {
@@ -2443,13 +2158,14 @@ type ResponseGetVtxos = ResponseEnvelope & {
 type RequestGetSpendableVtxos = RequestEnvelope & {
     type: "GET_SPENDABLE_VTXOS";
     payload: {
-        filter?: GetVtxosFilter;
+        filter?: GetSpendableVtxosFilter;
     };
 };
 type ResponseGetSpendableVtxos = ResponseEnvelope & {
     type: "SPENDABLE_VTXOS";
     payload: {
         vtxos: Awaited<ReturnType<IWallet["getSpendableVtxos"]>>;
+        filterApplied?: boolean;
     };
 };
 type RequestGetBoardingUtxos = RequestEnvelope & {
@@ -2547,10 +2263,28 @@ type RequestGetContractsWithVtxos = RequestEnvelope & {
     type: "GET_CONTRACTS_WITH_VTXOS";
     payload: {
         filter?: GetContractsFilter;
+        options?: {
+            maxSyncAgeMs?: number;
+            unspentOnly?: boolean;
+            requireSynced?: boolean;
+        };
     };
 };
 type ResponseGetContractsWithVtxos = ResponseEnvelope & {
     type: "CONTRACTS_WITH_VTXOS";
+    payload: {
+        contracts: ContractWithVtxos[];
+        filterApplied?: boolean;
+    };
+};
+type RequestGetStoredContractsWithVtxos = RequestEnvelope & {
+    type: "GET_STORED_CONTRACTS_WITH_VTXOS";
+    payload: {
+        filter?: GetContractsFilter;
+    };
+};
+type ResponseGetStoredContractsWithVtxos = ResponseEnvelope & {
+    type: "STORED_CONTRACTS_WITH_VTXOS";
     payload: {
         contracts: ContractWithVtxos[];
     };
@@ -2558,26 +2292,26 @@ type ResponseGetContractsWithVtxos = ResponseEnvelope & {
 type RequestWatchScript = RequestEnvelope & {
     type: "WATCH_SCRIPT";
     payload: {
-        script: string;
+        script: string | string[];
         label?: string;
     };
 };
 type ResponseWatchScript = ResponseEnvelope & {
     type: "SCRIPT_WATCHED";
     payload: {
-        script: string;
+        script: string | string[];
     };
 };
 type RequestUnwatchScript = RequestEnvelope & {
     type: "UNWATCH_SCRIPT";
     payload: {
-        script: string;
+        script: string | string[];
     };
 };
 type ResponseUnwatchScript = ResponseEnvelope & {
     type: "SCRIPT_UNWATCHED";
     payload: {
-        script: string;
+        script: string | string[];
     };
 };
 type RequestGetWatchedScripts = RequestEnvelope & {
@@ -2607,6 +2341,11 @@ type RequestUpdateContract = RequestEnvelope & {
     payload: {
         script: string;
         updates: Partial<Omit<Contract, "id" | "createdAt">>;
+        /**
+         * Set only by the proxy's `setContractWatchState`, so the worker keeps its
+         * unchanged-state no-op. A worker predating the flag ignores it and writes.
+         */
+        watchStateOnly?: boolean;
     };
 };
 type ResponseUpdateContract = ResponseEnvelope & {
@@ -2615,6 +2354,10 @@ type ResponseUpdateContract = ResponseEnvelope & {
         contract: Contract;
     };
 };
+/** Answers a `watchStateOnly` update; carries no row, so nothing is re-read. */
+type ResponseContractWatchStateSet = ResponseEnvelope & {
+    type: "CONTRACT_WATCH_STATE_SET";
+};
 type RequestDeleteContract = RequestEnvelope & {
     type: "DELETE_CONTRACT";
     payload: {
@@ -2732,6 +2475,15 @@ type ResponseGetAllSpendingPaths = ResponseEnvelope & {
         paths: PathSelection[];
     };
 };
+type RequestGetUnsupportedContracts = RequestEnvelope & {
+    type: "GET_UNSUPPORTED_CONTRACTS";
+};
+type ResponseGetUnsupportedContracts = ResponseEnvelope & {
+    type: "UNSUPPORTED_CONTRACTS";
+    payload: {
+        contracts: Contract[];
+    };
+};
 type ResponseSettleEvent = ResponseEnvelope & {
     broadcast: true;
     type: "SETTLE_EVENT";
@@ -2778,6 +2530,36 @@ type RequestSend = RequestEnvelope & {
         recipients: [Recipient, ...Recipient[]];
         /** @see SendParams.selectedVtxos */
         selectedVtxos?: ExtendedVirtualCoin[];
+        /** @see SendParams.maxChangeFee */
+        maxChangeFee?: number;
+    };
+};
+type RequestSendWithDeadline = RequestEnvelope & {
+    type: "SEND_WITH_DEADLINE";
+    payload: {
+        recipients: [Recipient, ...Recipient[]];
+        selectedVtxos?: ExtendedVirtualCoin[];
+        /** @see SendParams.maxChangeFee */
+        maxChangeFee?: number;
+        validUntil: number;
+    };
+};
+type RequestSendWithInputExpiryFloor = RequestEnvelope & {
+    type: "SEND_WITH_INPUT_EXPIRY_FLOOR";
+    payload: {
+        recipients: [Recipient, ...Recipient[]];
+        selectedVtxos?: ExtendedVirtualCoin[];
+        /** @see SendParams.maxChangeFee */
+        maxChangeFee?: number;
+        inputExpiryFloor: InputExpiryFloor;
+        validUntil?: number;
+    };
+};
+type ResponseSendDeadlineExceeded = ResponseEnvelope & {
+    type: "SEND_DEADLINE_EXCEEDED";
+    error: Error;
+    payload: {
+        validUntil: number;
     };
 };
 type ResponseSend = ResponseEnvelope & {
@@ -2996,8 +2778,8 @@ type RequestRestoreWallet = RequestEnvelope & {
 type ResponseRestoreWallet = ResponseEnvelope & {
     type: "RESTORE_WALLET_SUCCESS";
 };
-type WalletUpdaterRequest = RequestInitWallet | RequestSettle | RequestGetAddress | RequestGetBoardingAddress | RequestGetArkadeInfo | RequestIndexerGetVtxos | RequestIndexerGetVirtualTxs | RequestSubmitTx | RequestFinalizeTx | RequestGetBalance | RequestGetVtxos | RequestGetSpendableVtxos | RequestGetBoardingUtxos | RequestGetTransactionHistory | RequestGetStatus | RequestGetContractSyncState | RequestClear | RequestReloadWallet | RequestSignTransaction | RequestCreateContract | RequestGetContracts | RequestGetContractsWithVtxos | RequestWatchScript | RequestUnwatchScript | RequestGetWatchedScripts | RequestAnnotateVtxos | RequestUpdateContract | RequestDeleteContract | RequestGetSpendablePaths | RequestGetAllSpendingPaths | RequestIsContractManagerWatching | RequestRefreshVtxos | RequestRefreshOutpoints | RequestGetCurrentSigningDescriptor | RequestGetNextSigningDescriptor | RequestGetNewAddresses | RequestGetUsedSigningDescriptors | RequestAdvanceSigningDescriptorWatermark | RequestSend | RequestGetAssetDetails | RequestIssue | RequestReissue | RequestBurn | RequestDelegate | RequestGetDelegateInfo | RequestRecoverVtxos | RequestGetRecoverableBalance | RequestGetExpiringVtxos | RequestRenewVtxos | RequestGetExpiredBoardingUtxos | RequestSweepExpiredBoardingUtxos | RequestMigrateDeprecatedSignerVtxos | RequestGetDeprecatedSignerStatus | RequestRestoreWallet;
-type WalletUpdaterResponse = ResponseEnvelope & (ResponseInitWallet | ResponseSettle | ResponseSettleEvent | ResponseGetAddress | ResponseGetBoardingAddress | ResponseGetArkadeInfo | ResponseIndexerGetVtxos | ResponseIndexerGetVirtualTxs | ResponseSubmitTx | ResponseFinalizeTx | ResponseGetBalance | ResponseGetVtxos | ResponseGetSpendableVtxos | ResponseGetBoardingUtxos | ResponseGetTransactionHistory | ResponseGetStatus | ResponseGetContractSyncState | ResponseClear | ResponseReloadWallet | ResponseUtxoUpdate | ResponseVtxoUpdate | ResponseSignTransaction | ResponseCreateContract | ResponseGetContracts | ResponseGetContractsWithVtxos | ResponseWatchScript | ResponseUnwatchScript | ResponseGetWatchedScripts | ResponseAnnotateVtxos | ResponseUpdateContract | ResponseDeleteContract | ResponseGetSpendablePaths | ResponseGetAllSpendingPaths | ResponseIsContractManagerWatching | ResponseRefreshVtxos | ResponseRefreshOutpoints | ResponseGetCurrentSigningDescriptor | ResponseGetNextSigningDescriptor | ResponseGetNewAddresses | ResponseGetUsedSigningDescriptors | ResponseAdvanceSigningDescriptorWatermark | ResponseContractEvent | ResponseSend | ResponseGetAssetDetails | ResponseIssue | ResponseReissue | ResponseBurn | ResponseDelegate | ResponseGetDelegateInfo | ResponseRecoverVtxos | ResponseRecoverVtxosEvent | ResponseGetRecoverableBalance | ResponseGetExpiringVtxos | ResponseRenewVtxos | ResponseRenewVtxosEvent | ResponseGetExpiredBoardingUtxos | ResponseSweepExpiredBoardingUtxos | ResponseMigrateDeprecatedSignerVtxos | ResponseMigrateDeprecatedSignerVtxosEvent | ResponseGetDeprecatedSignerStatus | ResponseRestoreWallet);
+type WalletUpdaterRequest = RequestInitWallet | RequestSettle | RequestGetAddress | RequestGetBoardingAddress | RequestGetArkadeInfo | RequestIndexerGetVtxos | RequestIndexerGetVirtualTxs | RequestSubmitTx | RequestFinalizeTx | RequestGetBalance | RequestGetVtxos | RequestGetSpendableVtxos | RequestGetBoardingUtxos | RequestGetTransactionHistory | RequestGetStatus | RequestGetContractSyncState | RequestClear | RequestReloadWallet | RequestSignTransaction | RequestCreateContract | RequestGetContracts | RequestGetContractsWithVtxos | RequestGetStoredContractsWithVtxos | RequestWatchScript | RequestUnwatchScript | RequestGetWatchedScripts | RequestAnnotateVtxos | RequestUpdateContract | RequestDeleteContract | RequestGetSpendablePaths | RequestGetAllSpendingPaths | RequestGetUnsupportedContracts | RequestIsContractManagerWatching | RequestRefreshVtxos | RequestRefreshOutpoints | RequestGetCurrentSigningDescriptor | RequestGetNextSigningDescriptor | RequestGetNewAddresses | RequestGetUsedSigningDescriptors | RequestAdvanceSigningDescriptorWatermark | RequestSend | RequestSendWithDeadline | RequestSendWithInputExpiryFloor | RequestGetAssetDetails | RequestIssue | RequestReissue | RequestBurn | RequestDelegate | RequestGetDelegateInfo | RequestRecoverVtxos | RequestGetRecoverableBalance | RequestGetExpiringVtxos | RequestRenewVtxos | RequestGetExpiredBoardingUtxos | RequestSweepExpiredBoardingUtxos | RequestMigrateDeprecatedSignerVtxos | RequestGetDeprecatedSignerStatus | RequestRestoreWallet;
+type WalletUpdaterResponse = ResponseEnvelope & (ResponseInitWallet | ResponseSettle | ResponseSettleEvent | ResponseGetAddress | ResponseGetBoardingAddress | ResponseGetArkadeInfo | ResponseIndexerGetVtxos | ResponseIndexerGetVirtualTxs | ResponseSubmitTx | ResponseFinalizeTx | ResponseGetBalance | ResponseGetVtxos | ResponseGetSpendableVtxos | ResponseGetBoardingUtxos | ResponseGetTransactionHistory | ResponseGetStatus | ResponseGetContractSyncState | ResponseClear | ResponseReloadWallet | ResponseUtxoUpdate | ResponseVtxoUpdate | ResponseSignTransaction | ResponseCreateContract | ResponseGetContracts | ResponseGetContractsWithVtxos | ResponseGetStoredContractsWithVtxos | ResponseWatchScript | ResponseUnwatchScript | ResponseGetWatchedScripts | ResponseAnnotateVtxos | ResponseUpdateContract | ResponseContractWatchStateSet | ResponseDeleteContract | ResponseGetSpendablePaths | ResponseGetAllSpendingPaths | ResponseGetUnsupportedContracts | ResponseIsContractManagerWatching | ResponseRefreshVtxos | ResponseRefreshOutpoints | ResponseGetCurrentSigningDescriptor | ResponseGetNextSigningDescriptor | ResponseGetNewAddresses | ResponseGetUsedSigningDescriptors | ResponseAdvanceSigningDescriptorWatermark | ResponseContractEvent | ResponseSend | ResponseSendDeadlineExceeded | ResponseGetAssetDetails | ResponseIssue | ResponseReissue | ResponseBurn | ResponseDelegate | ResponseGetDelegateInfo | ResponseRecoverVtxos | ResponseRecoverVtxosEvent | ResponseGetRecoverableBalance | ResponseGetExpiringVtxos | ResponseRenewVtxos | ResponseRenewVtxosEvent | ResponseGetExpiredBoardingUtxos | ResponseSweepExpiredBoardingUtxos | ResponseMigrateDeprecatedSignerVtxos | ResponseMigrateDeprecatedSignerVtxosEvent | ResponseGetDeprecatedSignerStatus | ResponseRestoreWallet);
 declare class WalletMessageHandler implements MessageHandler<WalletUpdaterRequest, WalletUpdaterResponse> {
     readonly messageTag: string;
     private wallet;
@@ -3011,6 +2793,7 @@ declare class WalletMessageHandler implements MessageHandler<WalletUpdaterReques
     private channel;
     private incomingFundsEpoch;
     private contractEventsEpoch;
+    private boardingEpoch;
     /** Per-request progress callbacks: ends with the handler, not with a re-init. */
     private requestEpoch;
     /**
@@ -3037,6 +2820,10 @@ declare class WalletMessageHandler implements MessageHandler<WalletUpdaterReques
     isLongRunning(message: WalletUpdaterRequest): boolean;
     handleMessage(message: WalletUpdaterRequest): Promise<WalletUpdaterResponse>;
     private handleInitWallet;
+    /** @see RequestInitWallet.payload.lazyBoarding */
+    private lazyBoardingInit;
+    /** Set once this session has actually fetched the boarding addresses. */
+    private boardingLoaded;
     /**
      * The worker's own balance. Same bucketing rules as `Wallet.getBalance` —
      * both call {@link computeOffchainBalance} — but deliberately a different
@@ -3046,14 +2833,26 @@ declare class WalletMessageHandler implements MessageHandler<WalletUpdaterReques
      * runs over this method's local snapshot instead.
      */
     private handleGetBalance;
-    private getAllBoardingUtxos;
+    private getBoardingUtxosForBalance;
     private onWalletInitialized;
     /**
-     * Refresh virtual outputs, boarding inputs, and transaction history from cache.
-     * Shared by onWalletInitialized (full bootstrap) and reloadWallet
-     * (post-refresh), avoiding duplicate subscriptions and VtxoManager restarts.
+     * Refresh boarding inputs and transaction history. The virtual outputs come
+     * from the contract manager, which runs before this. Shared by
+     * onWalletInitialized (full bootstrap) and reloadWallet (post-refresh),
+     * avoiding duplicate subscriptions and VtxoManager restarts.
+     *
+     * Both legs reach the onchain provider, so `lazyBoarding` moves them both
+     * off the caller's path. @see RequestInitWallet.payload.lazyBoarding
      */
     private refreshCachedData;
+    /** @param gen - set by a background caller; each write is skipped once it goes stale. */
+    private refreshHistoryCache;
+    /**
+     * @param gen - set by a background caller; each write here is skipped once it goes stale.
+     *   The fetch saves the fetched rows itself, before control returns, so that one write is
+     *   outside this check.
+     */
+    private refreshBoardingCache;
     /**
      * Force a full VTXO refresh from the indexer, then refresh cached data.
      * Used by RELOAD_WALLET to ensure fresh data without re-subscribing
@@ -3072,6 +2871,14 @@ declare class WalletMessageHandler implements MessageHandler<WalletUpdaterReques
     /**
      * Read all virtual outputs from the repository, aggregated across all contract
      * addresses and the wallet's primary address, with deduplication.
+     *
+     * Recovery-only contracts (imported by `claimCash` for server-swept
+     * arkcash) are excluded by default, mirroring {@link ReadonlyWallet.getVtxos}:
+     * they are settled in their own isolated intent and must stay out of the
+     * wallet's balance / VTXO / coin-selection / pending-tx views that read this.
+     * The transaction-history caller opts back in via `includeRecoveryOnly` to
+     * match the non-worker `getTransactionHistory`, which reads contracts
+     * directly and does include them.
      */
     private getVtxosFromRepo;
     /**
@@ -3086,6 +2893,9 @@ declare class WalletMessageHandler implements MessageHandler<WalletUpdaterReques
      * VTXOs with no matching row in the gate, and `gatedContracts` lists only
      * what it knows is closed — so the coins of a just-registered escrowed
      * contract would count as available until the next poll.
+     *
+     * Recovery-only contracts are skipped unless `includeRecoveryOnly` (see
+     * {@link getVtxosFromRepo}).
      */
     private repoSnapshot;
     /**
@@ -3138,6 +2948,10 @@ declare const DEFAULT_MESSAGE_TIMEOUTS: Readonly<Record<RequestType, number>>;
  * ```
  */
 interface ServiceWorkerWalletOptions {
+    /** Start contract synchronization in the background; inspect provider connection state. */
+    lazyInitialization?: boolean;
+    /** Defer boarding and history loading; render boarding.loaded=false as unknown. */
+    lazyBoarding?: boolean;
     /** Arkade server endpoint and optional public key. */
     arkServer?: {
         url: string;
@@ -3161,6 +2975,8 @@ interface ServiceWorkerWalletOptions {
     messageBusTimeoutMs?: number;
     /** Optional settlement configuration forwarded to the worker wallet. */
     settlementConfig?: SettlementConfig | false;
+    /** Forwarded to the worker wallet. @see WalletConfig.concurrentSpending */
+    concurrentSpending?: boolean;
     /**
      * Receive-address strategy forwarded to the worker wallet.
      *
@@ -3179,17 +2995,13 @@ interface ServiceWorkerWalletOptions {
      */
     lookAheadWindow?: number;
     /**
-     * Timelock floors forwarded to the worker wallet. Lowering either below its
+     * Batch expiry floor forwarded to the worker wallet. Lowering it below its
      * per-network default relaxes a fund-safety bound; intended for local
-     * testing. The fast public test networks whose arkd runs below the
-     * mainnet-grade checkpoint floor (signet, mutinynet) are defaulted to their
-     * own advertised value, so neither needs these set.
+     * testing.
      *
      * @see WalletConfig.minBatchExpirySeconds
      */
     minBatchExpirySeconds?: bigint;
-    /** @see WalletConfig.minCheckpointExitDelaySeconds */
-    minCheckpointExitDelaySeconds?: bigint;
     /**
      * Per-request timeout overrides for wallet-updater messages.
      * @see DEFAULT_MESSAGE_TIMEOUTS
@@ -3219,6 +3031,7 @@ type ServiceWorkerWalletSetupOptions = ServiceWorkerWalletOptions & {
     serviceWorkerActivationTimeoutMs?: number;
 };
 type MessageBusInitConfig = {
+    lazyInitialization?: boolean;
     wallet: SerializedIdentity;
     arkServer: {
         url: string;
@@ -3227,11 +3040,11 @@ type MessageBusInitConfig = {
     delegateUrl?: string;
     timeoutMs?: number;
     settlementConfig?: SettlementConfig | false;
+    concurrentSpending?: boolean;
     walletMode?: ServiceWorkerWalletMode;
     watcherConfig?: Partial<Omit<ContractWatcherConfig, "indexerProvider">>;
     lookAheadWindow?: number;
     minBatchExpirySeconds?: bigint;
-    minCheckpointExitDelaySeconds?: bigint;
     messageTimeouts?: Record<string, number>;
 };
 declare class ServiceWorkerReadonlyWallet implements IReadonlyWallet {
@@ -3246,13 +3059,6 @@ declare class ServiceWorkerReadonlyWallet implements IReadonlyWallet {
     protected initWalletPayload: RequestInitWallet["payload"] | null;
     protected messageBusTimeoutMs?: number;
     protected messageTimeouts: Record<RequestType, number>;
-    protected arkServer?: {
-        url: string;
-        publicKey?: string;
-    };
-    protected delegateUrl?: string;
-    protected watcherConfig?: Partial<Omit<ContractWatcherConfig, "indexerProvider">>;
-    protected settlementConfig?: SettlementConfig | false;
     private reinitPromise;
     private pingPromise;
     private inflightRequests;
@@ -3267,6 +3073,8 @@ declare class ServiceWorkerReadonlyWallet implements IReadonlyWallet {
      * @throws Error if service-worker initialization fails
      */
     static create(options: ServiceWorkerWalletCreateOptions): Promise<ServiceWorkerReadonlyWallet>;
+    /** Shared tail of both `create()` factories: boot the bus, INIT_WALLET, cache for reinit. */
+    protected static bootstrap<W extends ServiceWorkerReadonlyWallet>(wallet: W, options: ServiceWorkerWalletCreateOptions, serializedWallet: SerializedIdentity, busConfig: Omit<MessageBusInitConfig, "wallet" | "arkServer" | "messageTimeouts">): Promise<W>;
     /**
      * Simplified setup method that handles service worker registration
      * and wallet initialization automatically.
@@ -3291,20 +3099,8 @@ declare class ServiceWorkerReadonlyWallet implements IReadonlyWallet {
         onEvent: (response: WalletUpdaterResponse) => void;
         isComplete: (response: WalletUpdaterResponse) => boolean;
     }): Promise<WalletUpdaterResponse>;
-    /**
-     * Produce a serialized envelope for the wallet's identity. The base
-     * class always emits a readonly envelope; `ServiceWorkerWallet`
-     * overrides to emit a signing envelope.
-     */
-    protected serializeIdentity(): Promise<SerializedIdentity>;
-    /**
-     * Return the cached init config, or rebuild one from live instance
-     * state when the cache was never populated. Recovery path for
-     * SDK-factory-created wallets; manual constructor bypasses do not
-     * retain enough state here and will hit the "never initialized" throw.
-     */
+    /** The init config cached by `create()`; manually constructed wallets have none. */
     protected buildInitConfig(): Promise<MessageBusInitConfig>;
-    /** Minimal INIT_WALLET payload used on reinitialize when the cache is gone. */
     protected buildInitWalletPayload(): RequestInitWallet["payload"];
     private reinitialize;
     /**
@@ -3360,7 +3156,7 @@ declare class ServiceWorkerReadonlyWallet implements IReadonlyWallet {
      * and falling back to `GET_VTXOS` there would silently spend ungated coins.
      * Fail closed — loud and recoverable — rather than make the gate advisory.
      */
-    getSpendableVtxos(filter?: GetVtxosFilter): Promise<NormalizedExtendedVirtualCoin[]>;
+    getSpendableVtxos(filter?: GetSpendableVtxosFilter): Promise<NormalizedExtendedVirtualCoin[]>;
     /**
      * Trigger a wallet reload inside the service worker.
      *
@@ -3377,9 +3173,11 @@ declare class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet implements
     private readonly _assetManager;
     private readonly hasDelegate;
     private _restoreInFlight?;
+    private _concurrentSpending;
+    /** @see WalletConfig.concurrentSpending */
+    get concurrentSpending(): boolean;
     protected constructor(serviceWorker: ServiceWorker, identity: Identity, walletRepository: WalletRepository, contractRepository: ContractRepository, messageTag: string, hasDelegate: boolean);
     get assetManager(): IAssetManager;
-    protected serializeIdentity(): Promise<SerializedIdentity>;
     static create(options: ServiceWorkerWalletCreateOptions): Promise<ServiceWorkerWallet>;
     /**
      * Simplified setup method that handles service worker registration
@@ -3467,7 +3265,7 @@ declare class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet implements
 }
 
 /**
- * A zero-value anchor output.
+ * A zero-value anchor output. An ark tx overrides the amount to carry its fee.
  */
 declare const P2A: {
     script: Uint8Array<ArrayBuffer>;
@@ -3486,7 +3284,7 @@ interface AnchorBumper {
  *
  * @example
  * ```typescript
- * const wallet = await OnchainWallet.create(identity, 'mainnet');
+ * const wallet = await OnchainWallet.create(identity, 'bitcoin');
  * const balance = await wallet.getBalance();
  * const txid = await wallet.send({
  *   address: 'bc1...',
@@ -3873,6 +3671,13 @@ declare class ElectrumOnchainProvider implements OnchainProvider {
         spent: boolean;
         txid: string;
     }[]>;
+    /** Reads `vout`'s script alone: another output of a tx someone else built (their change, a
+     *  service's fee address) can have a history Fulcrum answers empty and electrs refuses. */
+    getTxOutspend(txid: string, vout: number): Promise<{
+        spent: boolean;
+        txid: string;
+    }>;
+    private resolveOutspends;
     getTransactions(address: string): Promise<ExplorerTransaction[]>;
     /**
      * Resolve a list of `{tx_hash, height}` entries (as returned by the
@@ -4112,6 +3917,21 @@ declare function signAndSubmitOffchainTx(params: {
     /** Forwarded to {@link submitOffchainTx}; omitted, nothing is checked. */
     verifyServerSignatures?: VerifyServerSignatures;
 }): Promise<string>;
+/**
+ * Sign the caller's inputs of a pre-built offchain tx and submit it through the emulator, which
+ * co-signs and finalizes it with arkd. The checkpoints of `inputIndexes` are signed up front: the
+ * emulator verifies them before its own arkd handshake. An emulator-only leaf passes no inputs and
+ * no signer.
+ */
+declare function submitViaEmulator(emulator: Pick<EmulatorProvider, "submitTx">, offchainTx: OffchainTx, signer: {
+    sign(tx: Transaction, inputIndexes?: number[]): Promise<Transaction>;
+} | undefined, opts: {
+    inputIndexes: number[];
+}): Promise<{
+    txid: string;
+    signedArkTx: string;
+    signedCheckpointTxs: string[];
+}>;
 /**
  * Decorate a signer so it reveals `preimage` on every input it signs.
  *
@@ -4366,17 +4186,19 @@ declare class ArkNote implements ExtendedCoin {
 }
 
 /**
- * ArkadeCash is a bearer instrument for the Ark protocol.
+ * ArkadeCash is a bearer instrument for the Arkade.
  * It encodes a private key and contract parameters as a bech32m string,
  * enabling wallet-to-wallet transfers without address exchange.
  *
- * Format: arkadecash1... (bech32m encoded)
+ * Format: arkadecash1... / tarkadecash1... (bech32m encoded)
  * Payload: version (1 byte) + private key (32 bytes) + server pubkey (32 bytes) + csv timelock sequence (4 bytes)
  */
 declare class ArkadeCash {
     readonly csvTimelock: RelativeTimelock;
     readonly hrp: string;
     static readonly DefaultHRP = "arkadecash";
+    /** The only prefixes minted or accepted: mainnet and test networks. */
+    static readonly HRPs: readonly string[];
     static readonly Version = 0;
     static readonly PayloadLength: number;
     private readonly _privateKey;
@@ -4397,82 +4219,6 @@ declare class ArkadeCash {
     address(addressHrp: string): ArkAddress;
 }
 
-/**
- * Emulator REST client.
- *
- * The emulator is a signing service that executes Arkade scripts
- * and co-signs transactions when the scripts pass validation.
- *
- * The read here goes through `baseFetch`, the SDK's shared fetch boundary, so
- * it picks up whatever policy that boundary carries. The four submit calls
- * deliberately do not: aborting a submit would not tell the caller whether the
- * emulator signed, and none of them has a way to find out, so they stay on the
- * global `fetch` with their transport-error type unchanged.
- */
-
-interface EmulatorInfo {
-    signerPubkey: string;
-}
-interface EmulatorProvider {
-    getInfo(): Promise<EmulatorInfo>;
-    submitTx(arkTx: string, checkpointTxs: string[]): Promise<{
-        signedArkTx: string;
-        signedCheckpointTxs: string[];
-    }>;
-    submitIntent(intent: {
-        proof: string;
-        message: Intent.RegisterMessage;
-    }): Promise<string>;
-    submitFinalization(intent: {
-        proof: string;
-        message: Intent.RegisterMessage;
-    }, forfeits: string[], connectorTree: ConnectorTreeNode[] | null, commitmentTx: string): Promise<{
-        signedForfeits: string[];
-        signedCommitmentTx?: string;
-    }>;
-    submitOnchainTx(tx: string): Promise<{
-        signedTx: string;
-    }>;
-}
-interface ConnectorTreeNode {
-    txid: string;
-    tx: string;
-    children: Record<string, string>;
-}
-/**
- * REST-based emulator client.
- *
- * @example
- * ```typescript
- * const client = new RestEmulatorProvider('http://localhost:7073');
- * const info = await client.getInfo();
- * console.log('Emulator pubkey:', info.signerPubkey);
- * ```
- */
-declare class RestEmulatorProvider implements EmulatorProvider {
-    serverUrl: string;
-    constructor(serverUrl: string);
-    getInfo(): Promise<EmulatorInfo>;
-    submitTx(arkTx: string, checkpointTxs: string[]): Promise<{
-        signedArkTx: string;
-        signedCheckpointTxs: string[];
-    }>;
-    submitIntent(intent: {
-        proof: string;
-        message: Intent.RegisterMessage;
-    }): Promise<string>;
-    submitFinalization(intent: {
-        proof: string;
-        message: Intent.RegisterMessage;
-    }, forfeits: string[], connectorTree: ConnectorTreeNode[] | null, commitmentTx: string): Promise<{
-        signedForfeits: string[];
-        signedCommitmentTx?: string;
-    }>;
-    submitOnchainTx(tx: string): Promise<{
-        signedTx: string;
-    }>;
-}
-
 /**
  * Arkade Batch Handler
  *
@@ -5028,16 +4774,18 @@ declare const UnilateralExit: {
  *
  * Everything else (4xx, invalid JSON, schema violations, network mismatch,
  * unsupported network) is terminal and returns `false`.
- *
- * NOTE (Step 2, Scope 2): this classifies the errors currently produced by the
- * boot-critical `getInfo` path. Normalizing the indexer's per-branch
- * `!res.ok` throws and the remaining Ark RPC methods into
- * {@link ProviderUnavailableError} is the broader Scope-2 work still pending.
  */
 declare function isRetryableProviderError(error: unknown): boolean;
 
+/** Raised only before provider submission, so callers can release an unsent reservation. */
+declare class SendDeadlineExceededError extends Error {
+    constructor(validUntil: number);
+}
+declare function captureSendDeadline(value: unknown, required?: boolean): number | undefined;
+declare function assertSendDeadline(validUntil?: number): void;
+
 declare function validateConnectorsTxGraph(settlementTxB64: string, connectorsGraph: TxTree): void;
-declare function validateVtxoTxGraph(graph: TxTree, roundTransaction: Transaction$2, sweepTapTreeRoot: Uint8Array): void;
+declare function validateVtxoTxGraph(graph: TxTree, roundTransaction: Transaction, sweepTapTreeRoot: Uint8Array): void;
 
 /**
  * Assert the commitment tx received at batch finalization is the one validated
@@ -5070,6 +4818,19 @@ declare function assertFinalCommitmentMatchesValidated(finalCommitmentTx: Transa
  */
 declare function validateBatchRecipients(commitmentTx: Transaction, vtxoTreeLeaves: Transaction[], recipients: Recipient[], network: Network): void;
 
+/**
+ * Decode and validate a server-supplied `checkpointTapscript`.
+ *
+ * Every offchain send/claim builds its checkpoint outputs' server-claim leaf from this script, so
+ * a sub-floor or wrong-pubkey value lets the operator sweep an in-flight checkpoint before it
+ * settles. This is the sole gate: callers must use the returned script, not decode their own.
+ *
+ * @throws {ServerResponseMismatchError} if the script fails to decode, its
+ *   timelock is out of policy, or its pubkey does not match
+ *   `advertisedForfeitPubkey` (when set).
+ */
+declare function assertValidServerUnrollScript(checkpointTapscript: string, network: Network, advertisedForfeitPubkey?: Bytes): CSVMultisigTapscript.Type;
+
 /**
  * Build a forfeit transaction that spends the provided inputs to a single forfeit output.
  *
@@ -5178,14 +4939,16 @@ declare class Extension {
 /**
  * Arkade Script Opcodes
  *
- * This module defines ONLY Arkade-specific opcodes (0xb3, 0xc3-0xf6).
+ * This module defines ONLY Arkade-specific opcodes (0xb3, 0xbb, 0xc3-0xf8).
  * Standard Bitcoin opcodes are imported from @scure/btc-signer.
  *
- * Reference: arkade-os/emulator v0.0.4 pkg/arkade/opcode.go
+ * Reference: arkade-os/emulator pkg/arkade/opcode.go.
+ * Byte 0xdc is OP_CHECKTIME, matching emulator v0.0.8 and compiler artifacts.
  */
 
 declare const ARKADE_OP: {
     readonly MERKLEBRANCHVERIFY: 179;
+    readonly PUT: 187;
     readonly DIGEST: 195;
     readonly SHA256INITIALIZE: 196;
     readonly SHA256UPDATE: 197;
@@ -5209,6 +4972,8 @@ declare const ARKADE_OP: {
     readonly BIN2NUM: 216;
     readonly REVERSEBYTES: 217;
     readonly MODEXP: 218;
+    readonly PUSHEXPIRY: 219;
+    readonly CHECKTIME: 220;
     readonly ECADD: 224;
     readonly ECMUL: 225;
     readonly ECPAIRING: 226;
@@ -5232,6 +4997,8 @@ declare const ARKADE_OP: {
     readonly INSPECTPACKET: 244;
     readonly INSPECTINPUTPACKET: 245;
     readonly SIGHASH: 246;
+    readonly TUNNEL: 247;
+    readonly INSPECTINTENTMESSAGE: 248;
 };
 declare const ARKADE_OPCODES: number[];
 declare const ARKADE_OPCODE_NAMES: Record<number, string>;
@@ -5280,6 +5047,7 @@ declare function getOpcodeValue(name: string): number | undefined;
  */
 declare const ARKADE_OPS: {
     readonly MERKLEBRANCHVERIFY: 179;
+    readonly PUT: 187;
     readonly DIGEST: 195;
     readonly SHA256INITIALIZE: 196;
     readonly SHA256UPDATE: 197;
@@ -5303,6 +5071,8 @@ declare const ARKADE_OPS: {
     readonly BIN2NUM: 216;
     readonly REVERSEBYTES: 217;
     readonly MODEXP: 218;
+    readonly PUSHEXPIRY: 219;
+    readonly CHECKTIME: 220;
     readonly ECADD: 224;
     readonly ECMUL: 225;
     readonly ECPAIRING: 226;
@@ -5326,119 +5096,121 @@ declare const ARKADE_OPS: {
     readonly INSPECTPACKET: 244;
     readonly INSPECTINPUTPACKET: 245;
     readonly SIGHASH: 246;
-    readonly OP_0: number;
-    readonly PUSHDATA1: number;
-    readonly PUSHDATA2: number;
-    readonly PUSHDATA4: number;
-    readonly '1NEGATE': number;
-    readonly RESERVED: number;
-    readonly OP_1: number;
-    readonly OP_2: number;
-    readonly OP_3: number;
-    readonly OP_4: number;
-    readonly OP_5: number;
-    readonly OP_6: number;
-    readonly OP_7: number;
-    readonly OP_8: number;
-    readonly OP_9: number;
-    readonly OP_10: number;
-    readonly OP_11: number;
-    readonly OP_12: number;
-    readonly OP_13: number;
-    readonly OP_14: number;
-    readonly OP_15: number;
-    readonly OP_16: number;
-    readonly NOP: number;
-    readonly VER: number;
-    readonly IF: number;
-    readonly NOTIF: number;
-    readonly VERIF: number;
-    readonly VERNOTIF: number;
-    readonly ELSE: number;
-    readonly ENDIF: number;
-    readonly VERIFY: number;
-    readonly RETURN: number;
-    readonly TOALTSTACK: number;
-    readonly FROMALTSTACK: number;
-    readonly '2DROP': number;
-    readonly '2DUP': number;
-    readonly '3DUP': number;
-    readonly '2OVER': number;
-    readonly '2ROT': number;
-    readonly '2SWAP': number;
-    readonly IFDUP: number;
-    readonly DEPTH: number;
-    readonly DROP: number;
-    readonly DUP: number;
-    readonly NIP: number;
-    readonly OVER: number;
-    readonly PICK: number;
-    readonly ROLL: number;
-    readonly ROT: number;
-    readonly SWAP: number;
-    readonly TUCK: number;
-    readonly CAT: number;
-    readonly SUBSTR: number;
-    readonly LEFT: number;
-    readonly RIGHT: number;
-    readonly SIZE: number;
-    readonly INVERT: number;
-    readonly AND: number;
-    readonly OR: number;
-    readonly XOR: number;
-    readonly EQUAL: number;
-    readonly EQUALVERIFY: number;
-    readonly RESERVED1: number;
-    readonly RESERVED2: number;
-    readonly '1ADD': number;
-    readonly '1SUB': number;
-    readonly '2MUL': number;
-    readonly '2DIV': number;
-    readonly NEGATE: number;
-    readonly ABS: number;
-    readonly NOT: number;
-    readonly '0NOTEQUAL': number;
-    readonly ADD: number;
-    readonly SUB: number;
-    readonly MUL: number;
-    readonly DIV: number;
-    readonly MOD: number;
-    readonly LSHIFT: number;
-    readonly RSHIFT: number;
-    readonly BOOLAND: number;
-    readonly BOOLOR: number;
-    readonly NUMEQUAL: number;
-    readonly NUMEQUALVERIFY: number;
-    readonly NUMNOTEQUAL: number;
-    readonly LESSTHAN: number;
-    readonly GREATERTHAN: number;
-    readonly LESSTHANOREQUAL: number;
-    readonly GREATERTHANOREQUAL: number;
-    readonly MIN: number;
-    readonly MAX: number;
-    readonly WITHIN: number;
-    readonly RIPEMD160: number;
-    readonly SHA1: number;
-    readonly SHA256: number;
-    readonly HASH160: number;
-    readonly HASH256: number;
-    readonly CODESEPARATOR: number;
-    readonly CHECKSIG: number;
-    readonly CHECKSIGVERIFY: number;
-    readonly CHECKMULTISIG: number;
-    readonly CHECKMULTISIGVERIFY: number;
-    readonly NOP1: number;
-    readonly CHECKLOCKTIMEVERIFY: number;
-    readonly CHECKSEQUENCEVERIFY: number;
-    readonly NOP4: number;
-    readonly NOP5: number;
-    readonly NOP6: number;
-    readonly NOP7: number;
-    readonly NOP8: number;
-    readonly NOP9: number;
-    readonly NOP10: number;
-    readonly CHECKSIGADD: number;
-    readonly INVALID: number;
+    readonly TUNNEL: 247;
+    readonly INSPECTINTENTMESSAGE: 248;
+    readonly OP_0: 0;
+    readonly PUSHDATA1: 76;
+    readonly PUSHDATA2: 77;
+    readonly PUSHDATA4: 78;
+    readonly '1NEGATE': 79;
+    readonly RESERVED: 80;
+    readonly OP_1: 81;
+    readonly OP_2: 82;
+    readonly OP_3: 83;
+    readonly OP_4: 84;
+    readonly OP_5: 85;
+    readonly OP_6: 86;
+    readonly OP_7: 87;
+    readonly OP_8: 88;
+    readonly OP_9: 89;
+    readonly OP_10: 90;
+    readonly OP_11: 91;
+    readonly OP_12: 92;
+    readonly OP_13: 93;
+    readonly OP_14: 94;
+    readonly OP_15: 95;
+    readonly OP_16: 96;
+    readonly NOP: 97;
+    readonly VER: 98;
+    readonly IF: 99;
+    readonly NOTIF: 100;
+    readonly VERIF: 101;
+    readonly VERNOTIF: 102;
+    readonly ELSE: 103;
+    readonly ENDIF: 104;
+    readonly VERIFY: 105;
+    readonly RETURN: 106;
+    readonly TOALTSTACK: 107;
+    readonly FROMALTSTACK: 108;
+    readonly '2DROP': 109;
+    readonly '2DUP': 110;
+    readonly '3DUP': 111;
+    readonly '2OVER': 112;
+    readonly '2ROT': 113;
+    readonly '2SWAP': 114;
+    readonly IFDUP: 115;
+    readonly DEPTH: 116;
+    readonly DROP: 117;
+    readonly DUP: 118;
+    readonly NIP: 119;
+    readonly OVER: 120;
+    readonly PICK: 121;
+    readonly ROLL: 122;
+    readonly ROT: 123;
+    readonly SWAP: 124;
+    readonly TUCK: 125;
+    readonly CAT: 126;
+    readonly SUBSTR: 127;
+    readonly LEFT: 128;
+    readonly RIGHT: 129;
+    readonly SIZE: 130;
+    readonly INVERT: 131;
+    readonly AND: 132;
+    readonly OR: 133;
+    readonly XOR: 134;
+    readonly EQUAL: 135;
+    readonly EQUALVERIFY: 136;
+    readonly RESERVED1: 137;
+    readonly RESERVED2: 138;
+    readonly '1ADD': 139;
+    readonly '1SUB': 140;
+    readonly '2MUL': 141;
+    readonly '2DIV': 142;
+    readonly NEGATE: 143;
+    readonly ABS: 144;
+    readonly NOT: 145;
+    readonly '0NOTEQUAL': 146;
+    readonly ADD: 147;
+    readonly SUB: 148;
+    readonly MUL: 149;
+    readonly DIV: 150;
+    readonly MOD: 151;
+    readonly LSHIFT: 152;
+    readonly RSHIFT: 153;
+    readonly BOOLAND: 154;
+    readonly BOOLOR: 155;
+    readonly NUMEQUAL: 156;
+    readonly NUMEQUALVERIFY: 157;
+    readonly NUMNOTEQUAL: 158;
+    readonly LESSTHAN: 159;
+    readonly GREATERTHAN: 160;
+    readonly LESSTHANOREQUAL: 161;
+    readonly GREATERTHANOREQUAL: 162;
+    readonly MIN: 163;
+    readonly MAX: 164;
+    readonly WITHIN: 165;
+    readonly RIPEMD160: 166;
+    readonly SHA1: 167;
+    readonly SHA256: 168;
+    readonly HASH160: 169;
+    readonly HASH256: 170;
+    readonly CODESEPARATOR: 171;
+    readonly CHECKSIG: 172;
+    readonly CHECKSIGVERIFY: 173;
+    readonly CHECKMULTISIG: 174;
+    readonly CHECKMULTISIGVERIFY: 175;
+    readonly NOP1: 176;
+    readonly CHECKLOCKTIMEVERIFY: 177;
+    readonly CHECKSEQUENCEVERIFY: 178;
+    readonly NOP4: 179;
+    readonly NOP5: 180;
+    readonly NOP6: 181;
+    readonly NOP7: 182;
+    readonly NOP8: 183;
+    readonly NOP9: 184;
+    readonly NOP10: 185;
+    readonly CHECKSIGADD: 186;
+    readonly INVALID: 255;
 };
 /** A single script operation: opcode string key, raw bytes, number, or bigint */
 type ArkadeScriptOP = keyof typeof ARKADE_OPS | Uint8Array | number | bigint;
@@ -5560,53 +5332,80 @@ declare namespace bignum {
   export { bignum_BIGNUM_MAX_BYTES as BIGNUM_MAX_BYTES, bignum_decode as decode, bignum_encode as encode };
 }
 
+/**
+ * Read the JSON `arkadec` writes into a {@link Program}: `$param` placeholders,
+ * @scure opcode names, and one structured tapleaf per compiler leaf.
+ */
+
+interface ArtifactParameter {
+    name: string;
+    type: string;
+}
+interface ArtifactStruct {
+    name: string;
+    fields: ArtifactParameter[];
+}
+interface ArtifactWitnessElement {
+    name: string;
+    type: string;
+    encoding?: string;
+    injected?: boolean;
+}
+interface ArtifactLeaf {
+    name: string;
+    witness?: ArtifactWitnessElement[];
+    asm: string[];
+}
+interface ArtifactCovenant {
+    inputs: ArtifactParameter[];
+    asm: string[];
+}
+interface ArtifactGroup {
+    name: string;
+    arkade?: ArtifactCovenant;
+    leaves: ArtifactLeaf[];
+}
+interface ContractArtifact {
+    formatVersion?: number;
+    contractName: string;
+    constructorInputs: ArtifactParameter[];
+    structs?: ArtifactStruct[];
+    functions: ArtifactGroup[];
+}
+/** `true` when `value` is an arkadec artifact rather than a Program. */
+declare function isContractArtifact(value: unknown): value is ContractArtifact;
+/** Adds `server`, and one param per child-output placeholder for the caller to bind to that output key. */
+declare function programFromArtifact(artifact: ContractArtifact): Program;
+
 /**
  * Arkade Contract — artifact-driven, high-level covenant API.
  *
- * Implements the Arkade contract model: a contract is a {@link Program} (a set of
- * named functions, each split into a `tapscript` segment enforced on-chain and an
- * `arkadeScript` segment emulated by the co-signing service). The same JS object
- * shape mirrors the compiler artifact, so a hand-written program today and the
- * compiler's JSON output later flow through the identical resolver.
- *
- * The SDK never interprets scripts: it resolves `$param` placeholders into bytes,
- * builds the taproot tree (resolving `$param` signers such as `$server`/`$user` from
- * the constructor args, plus the co-signer key tweaked by the arkade-script hash),
- * and assembles the spend from the per-segment witness layout. All key tweaking,
- * packet encoding and PSBT plumbing is internal — from the caller's side it is just
- * Arkade.
- *
- * Program → script compilation lives in {@link ArkadeProgramScript}
- * (./program.ts) and is shared with the generic `"arkade"` contract handler,
- * so a contract created here can be persisted, watched and re-derived through
- * the standard `src/contracts` pipeline: pass a `contractManager` to
- * {@link Arkade.connect} and call {@link ArkadeContract.register}.
- *
- * Contract functions are strongly typed from the program's literal shape: a
- * function declaring `inputs: [{ name: "preimage", type: "bytes" }]` produces a
- * `functions.claim(preimage: Uint8Array)` call signature. The type flows through
- * `arkade.contract(...)` automatically for inline literals; for a program stored
- * in a variable, annotate it with `satisfies Program` to preserve the literal
- * type (a plain `: Program` annotation would widen it away).
- *
- * Constructor `params` follow the same convention: bare name strings are
- * documentation only, while typed descriptors `{ name, type }` (the form the
- * ArkadeScript compiler emits) make the list authoritative — every declared
- * param must be bound, every `$name` reference must be declared, and bound
- * values are validated against their type at compilation.
- *
- * A covenant spend needs an `indexer`, not just an `emulator`: the co-signing
- * service resolves each input's prevout pkScript from the previous ark tx the
- * PSBT carries, and only the indexer can supply those bytes. Pure tapscript
- * spends go straight to arkd and need neither.
+ * A contract is a {@link Program}: named functions, each split into a `tapscript` segment
+ * enforced on-chain and an `arkadeScript` segment emulated by the co-signing service. Compiler
+ * artifacts are normalized into this model, sharing the resolver with hand-written programs.
+ * The SDK never interprets scripts; it resolves `$param` placeholders and signers, builds the
+ * taproot tree (co-signer key tweaked by the arkade-script hash) and assembles the spend.
+ *
+ * Compilation lives in {@link ArkadeProgramScript} and is shared with the `"arkade"` contract
+ * handler: pass a `contractManager` to {@link Arkade.connect} and call
+ * {@link ArkadeContract.register} to persist and watch a contract.
+ *
+ * Functions are typed from the program's literal shape (`inputs: [{ name: "preimage", type:
+ * "bytes" }]` → `functions.claim(preimage: Uint8Array)`). For a program stored in a variable use
+ * `satisfies Program`; a `: Program` annotation widens the literal type away. Typed `params`
+ * descriptors `{ name, type }` make the list authoritative (every param bound, every `$name`
+ * declared, values type-checked).
+ *
+ * A covenant spend needs an `indexer` as well as an `emulator`: the co-signer resolves each
+ * input's prevout from the previous ark tx the PSBT carries. Pure tapscript spends need neither.
  *
  * @example
  * ```typescript
  * const htlcProgram = {
- *     version: 0,
+ *     version: 1,
  *     name: "htlc", // metadata only — round-tripped, never compiled
  *     params: [
- *         { name: "hash", type: "hash" },
+ *         { name: "hash", type: "bytes20" },
  *         { name: "receiver", type: "pubkey" },
  *         { name: "amount", type: "int" },
  *         { name: "server", type: "pubkey" },
@@ -5630,21 +5429,17 @@ declare namespace bignum {
  * @module arkade/contract
  */
 
-/** The TS type of a single call argument, derived from its {@link InputRef}. */
-type ArgTsType<R> = R extends InputDef ? ArkadeValueType[R["type"]] : ArkadeArgValue;
 /** The argument tuple of a function, derived from its declared `inputs`. */
-type ArgsTuple<I extends readonly InputRef[]> = {
-    [K in keyof I]: ArgTsType<I[K]>;
+type ArgsTuple<I extends readonly InputDef[]> = {
+    [K in keyof I]: ArkadeValueType[I[K]["type"]];
 };
 /** The call signature arguments for one function (nullary when `inputs` is absent). */
 type FnArgs<F extends ArkadeFunction> = F extends {
-    inputs: infer I extends readonly InputRef[];
+    inputs: infer I extends readonly InputDef[];
 } ? ArgsTuple<I> : [];
 /**
- * The statically-typed `functions` map of a contract. When the program is a
- * concrete literal (specific function names), each entry is precisely typed from
- * its `inputs`. When the program is the widened {@link Program} (an index
- * signature), it falls back to the loose {@link CallableFunctions}.
+ * The statically-typed `functions` map of a contract: precisely typed per function for a literal
+ * program, the loose {@link CallableFunctions} for the widened {@link Program}.
  */
 type ContractFunctions<P extends Program> = string extends keyof P["functions"] ? CallableFunctions : {
     [K in keyof P["functions"]]: (...args: FnArgs<P["functions"][K]>) => ArkadeTransactionBuilder;
@@ -5655,13 +5450,9 @@ interface Utxo {
     vout: number;
     value: number;
     /**
-     * Raw wire bytes of the ark transaction that created this VTXO, attached as
-     * the PrevArkTx field on input 0.
-     *
-     * An override, not the only channel: covenant spends resolve the previous
-     * tx of every input through the client's indexer. Supply it when the tx is
-     * not yet indexable — a recursive covenant spending the output of an ark tx
-     * the caller just built — and the resolved value is suppressed for input 0.
+     * Raw bytes of the ark tx that created this VTXO, attached as input 0's PrevArkTx. Overrides
+     * the indexer-resolved value; supply it when the tx isn't indexable yet (a recursive covenant
+     * spending an ark tx the caller just built).
      */
     sourceTx?: Uint8Array;
 }
@@ -5697,33 +5488,64 @@ interface ArkadeSpendResult {
 }
 /** The callable spending paths of a contract. */
 type CallableFunctions = Record<string, (...args: ArkadeArgValue[]) => ArkadeTransactionBuilder>;
-/**
- * What {@link Arkade} needs from the Arkade server.
- *
- * Only `getInfo` is required — see {@link ArkadeConnectOptions.arkade} for why.
- * Named so a caller building a derivation-only client has a type to import
- * rather than reaching into the options bag.
- */
+/** What {@link Arkade} needs from the Arkade server; see {@link ArkadeConnectOptions.arkade}. */
 type ArkadeServerProvider = Pick<ArkProvider, "getInfo"> & Partial<ArkadeBroadcaster>;
-/** Options for {@link Arkade.connect}. */
-interface ArkadeConnectOptions {
+/** Fields shared by both forms of {@link ArkadeConnectOptions}. */
+interface ArkadeConnectCommonOptions {
+    /** Signer for paths that require a user signature; optional for watch-only. */
+    identity?: Identity;
     /**
-     * The Arkade server provider.
+     * Network for address derivation. Defaults to the network the server
+     * reports on `getInfo` — or the SDK default when the server names none.
+     */
+    network?: Network;
+    /**
+     * Co-sign with this emulator key (33-byte compressed hex) instead of the one pinned for
+     * `network`. Needed after a key rotation ahead of this SDK, for a self-hosted emulator, or on
+     * networks with no pinned key (signet, testnet, a hand-built `Network` — those throw without
+     * it). Setting it means trusting that operator as co-signer.
      *
-     * Only `getInfo` is required: it is what resolves the server key and
-     * checkpoint closure, and it is all a client needs to derive, register and
-     * inspect contracts. `submitTx`/`finalizeTx` are needed solely to
-     * broadcast, so a client built without them throws at `.send()` — the same
-     * deferred, explicit failure an absent `indexer` gives `getUtxos()` and an
-     * absent `emulator` gives a covenant spend. That lets a caller that already
-     * holds the server info (`wallet.getArkadeInfo()`) connect without a
-     * provider of its own, and without a second `/v1/info` round-trip.
+     * @see resolveEmulatorPubkey
+     */
+    emulatorPubkey?: string;
+    /**
+     * The wallet's contract manager (`wallet.getContractManager()`). Enables
+     * {@link ArkadeContract.register} and {@link ArkadeContract.on}, and makes
+     * {@link ArkadeContract.getUtxos} read repository-backed state for registered contracts
+     * instead of the indexer. Never disposed by {@link Arkade.dispose}.
+     */
+    contractManager?: IContractManager;
+}
+/**
+ * The one-liner form: name the deployment, and `connect` resolves the providers (and, for
+ * `{ network: "bitcoin" }`, the emulator).
+ */
+interface ArkadeConnectServiceOptions extends ArkadeConnectCommonOptions {
+    service: ArkadeService;
+    /**
+     * Persist contracts here. The client builds and owns a contract manager over it (with an
+     * in-memory VTXO store), enabling {@link ArkadeContract.register} and
+     * {@link ArkadeContract.on}; {@link Arkade.dispose} stops it. Exclusive with
+     * `contractManager`. Deliberately narrower than the wallet's `StorageConfig`.
+     */
+    storage?: {
+        contractRepository: ContractRepository;
+    };
+    arkade?: never;
+    emulator?: never;
+    indexer?: never;
+}
+/** The provider form: hand over providers you already hold (e.g. a wallet's). */
+interface ArkadeConnectProviderOptions extends ArkadeConnectCommonOptions {
+    /**
+     * The Arkade server provider. Only `getInfo` is required (enough to derive, register and
+     * inspect contracts); without `submitTx`/`finalizeTx`, `.send()` throws. So a caller already
+     * holding `wallet.getArkadeInfo()` can connect without a second `/v1/info` round-trip.
      */
     arkade: ArkadeServerProvider;
     /**
-     * The co-signing (introspector/emulator) service. Optional: only required for
-     * contracts whose functions have an `arkadeScript` (covenant paths). Pure
-     * tapscript contracts (multisig/timelock/hashlock) don't need it.
+     * The co-signing (introspector/emulator) service. Required only for functions with an
+     * `arkadeScript` (covenant paths).
      */
     emulator?: EmulatorProvider;
     /**
@@ -5732,36 +5554,31 @@ interface ArkadeConnectOptions {
      * {@link attachPrevArkTxs}). Required for covenant spends.
      */
     indexer?: Pick<IndexerProvider, "getVtxos" | "getVirtualTxs">;
-    /** Signer for paths that require a user signature; optional for watch-only. */
-    identity?: Identity;
-    /** Network for address derivation; defaults to the SDK default. */
-    network?: Network;
-    /**
-     * Co-sign with this emulator key (33-byte compressed hex) instead of the
-     * one pinned for `network`.
-     *
-     * Needed when a network's emulator key has rotated ahead of this SDK, for a
-     * self-hosted emulator, or on a network with no pinned key at all (signet,
-     * testnet, a hand-built `Network` — those throw without it). Setting it
-     * means trusting that operator as co-signer in place of the network's.
-     *
-     * @see resolveEmulatorPubkey
-     */
-    emulatorPubkey?: string;
-    /**
-     * The wallet's contract manager. When set, contracts created from this
-     * client can {@link ArkadeContract.register} themselves into the standard
-     * contract pipeline (persistence, watching, events), and
-     * {@link ArkadeContract.getUtxos} reads repository-backed state
-     * (offline-first) for registered contracts instead of querying the
-     * indexer directly. Obtain it via `wallet.getContractManager()`.
-     */
-    contractManager?: IContractManager;
+    service?: never;
+    storage?: never;
+}
+/** Options for {@link Arkade.connect}: `service` and `arkade` are exclusive. */
+type ArkadeConnectOptions = ArkadeConnectServiceOptions | ArkadeConnectProviderOptions;
+/** Event types {@link ArkadeContract.on} reports. */
+type ArkadeContractEventType = "vtxo_received" | "vtxo_spent" | "connection_reset";
+/** The event an {@link ArkadeContract.on} handle of type `T` receives. */
+type ArkadeContractEvent<T extends ArkadeContractEventType = ArkadeContractEventType> = T extends "connection_reset" ? Extract<ContractEvent, {
+    type: "connection_reset";
+}> : Extract<ContractVtxoEvent, {
+    type: T;
+}>;
+/** Returned by {@link ArkadeContract.on}. */
+interface ArkadeContractSubscription {
+    /** Stop delivery to this handle. Idempotent. */
+    off(): void;
 }
+type EventHandle = {
+    type: ArkadeContractEventType;
+    callback: (event: ArkadeContractEvent) => void | Promise<void>;
+};
 /**
- * A connected Arkade client. Holds the providers/identity/network and the
- * resolved network constants (server key, co-signer key, checkpoint closure),
- * so spinning up contracts is synchronous.
+ * A connected Arkade client holding the providers and resolved network constants (server key,
+ * co-signer key, checkpoint closure), so creating contracts is synchronous.
  */
 declare class Arkade {
     readonly arkProvider: ArkadeServerProvider;
@@ -5769,15 +5586,13 @@ declare class Arkade {
     readonly emulator: EmulatorProvider | undefined;
     readonly network: Network;
     readonly serverKey: Uint8Array;
+    /** Bare protocol delay (blocks below 512, seconds otherwise), resolved only when needed. */
+    readonly serverExitDelay?: bigint;
     /**
-     * The co-signer key covenants are built against (33-byte compressed),
-     * present only when an emulator is configured.
-     *
-     * Resolved from the network — or from `emulatorPubkey` — never from the
-     * emulator's own report. When a claim is refused because the co-signer
-     * disagrees, compare `hex.encode(arkade.emulatorKey)` against the
-     * `signerPubkey` your emulator serves on `/v1/info`: if they differ, the
-     * network rotated and this SDK's pin is stale.
+     * The co-signer key covenants are built against (33-byte compressed), present only when an
+     * emulator is configured. Resolved from the network or `emulatorPubkey`, never the emulator's
+     * own report. If a claim is refused, compare it with the emulator's `/v1/info` `signerPubkey`:
+     * a difference means the network rotated and this SDK's pin is stale.
      */
     readonly emulatorKey: Uint8Array | undefined;
     readonly checkpoint: CSVMultisigTapscript.Type;
@@ -5785,20 +5600,46 @@ declare class Arkade {
     readonly identity?: Identity;
     /** The signing identity's x-only public key, resolved at connect — identifies which inputs the wallet signs. */
     readonly userKey?: Uint8Array;
-    /** The wallet's contract manager, when contract persistence is wired up. */
+    /** The contract manager, when contract persistence is wired up (passed in or owned). */
     readonly contractManager?: IContractManager;
+    /** Whether {@link connect} built {@link contractManager}, so {@link dispose} must stop it. */
+    private readonly ownsContractManager;
+    /** {@link ArkadeContract.on} handles by contract script (hex). */
+    private readonly handles;
+    /** The single `onContractEvent` subscription fanning out to {@link handles}. */
+    private unsubscribeEvents?;
+    private disposed;
     private constructor();
-    /** Connect and resolve the server key, checkpoint closure and (if present) the co-signer key. */
+    /**
+     * Connect and resolve the server key, checkpoint closure and (if present) the co-signer key.
+     *
+     * @example
+     * ```typescript
+     * const arkade = await Arkade.connect({
+     *     service: { network: "bitcoin" },
+     *     identity,
+     *     storage: { contractRepository },
+     * });
+     * ```
+     */
     static connect(opts: ArkadeConnectOptions): Promise<Arkade>;
     /**
-     * Instantiate a contract from a program and its constructor arguments. The
-     * `program`'s literal type is preserved (`const` inference) so the resulting
-     * contract's `functions` map is strongly typed — `functions.<name>(...)`
-     * knows each argument's type from the function's `inputs` descriptors.
+     * Stop event delivery to every {@link ArkadeContract.on} handle and, when {@link connect}
+     * built the contract manager (`storage`), dispose it. A caller-passed manager keeps running.
+     */
+    dispose(): void;
+    /**
+     * @internal Add a handle for `script`, subscribing to the manager on first use; the last
+     * handle's `off()` releases the subscription.
+     */
+    addEventHandle(manager: IContractManager, script: string, handle: EventHandle): () => void;
+    private dispatch;
+    /**
+     * Instantiate a contract from a program and its constructor arguments. `const` inference keeps
+     * the program's literal type, so `functions` is strongly typed.
      *
-     * When the program declares a `server` or `user` param and the caller does
-     * not bind it, it defaults to the client's server key or the identity's
-     * key respectively; explicit args always win.
+     * Declared `server`/`user` params default to the client's keys. Compiler
+     * artifacts reserve the server key and exit delay to the connected server.
      */
     contract<const P extends Program>(program: P, args?: Record<string, ArkadeParamValue>): ArkadeContract<P>;
 }
@@ -5817,11 +5658,8 @@ declare class ArkadeContract<P extends Program = Program> {
     private readonly compiled;
     constructor(client: Arkade, program: P, args?: Record<string, ArkadeParamValue>, keys?: ProgramKeys);
     /**
-     * Rebuild a callable contract from a persisted `"arkade"` contract row
-     * (see {@link ArkadeContract.register}). The stored keys are used for
-     * compilation — not the client's current ones — so the derived script and
-     * address stay identical to the registered contract even after a server
-     * signer rotation.
+     * Rebuild a callable contract from a persisted `"arkade"` row. Compiles with the stored keys,
+     * not the client's current ones, so script and address survive a server signer rotation.
      */
     static fromContract(client: Arkade, contract: Contract): ArkadeContract;
     /** Resolve the {@link TapLeafScript} for a spending path by its index. */
@@ -5830,16 +5668,11 @@ declare class ArkadeContract<P extends Program = Program> {
     get address(): string;
     /** Taproot output script. */
     get pkScript(): Uint8Array;
-    /**
-     * Callable spending paths: `contract.functions.<name>(...args)`. Strongly
-     * typed from the program's literal type — each function's argument types are
-     * derived from its `inputs` descriptors (see {@link ContractFunctions}).
-     */
+    /** Callable spending paths: `functions.<name>(...args)` (see {@link ContractFunctions}). */
     get functions(): ContractFunctions<P>;
     /**
-     * The `createContract` payload for this contract — the serialized program,
-     * args and keys plus the derived script/address. Useful when registering
-     * through a manager the client does not hold.
+     * The `createContract` payload (serialized program, args, keys, script, address), for
+     * registering through a manager the client does not hold.
      */
     toContractParams(): {
         type: string;
@@ -5848,26 +5681,42 @@ declare class ArkadeContract<P extends Program = Program> {
         address: string;
     };
     /**
-     * Persist this contract through the wallet's {@link IContractManager} so it
-     * is tracked like any other contract type: stored in the contract
-     * repository, watched for VTXO events, counted in repository-backed
-     * balances, and re-derivable offline via the `"arkade"` contract handler.
-     * Idempotent — re-registering the same script is a no-op.
+     * Persist this contract through the wallet's {@link IContractManager} (stored, watched,
+     * counted in balances, re-derivable via the `"arkade"` handler). Idempotent per script.
      */
     register(options?: {
         label?: string;
         metadata?: Record<string, unknown>;
     }): Promise<Contract>;
     /**
-     * Spendable VTXOs locked by this contract.
+     * Report this contract's activity: `vtxo_received`/`vtxo_spent` for its script, and
+     * `connection_reset` when the manager's event stream reconnects. Registers the contract
+     * (idempotent) so it is persisted and watched; requires a contract manager (`storage` or
+     * `contractManager` on {@link Arkade.connect}).
      *
-     * When a `contractManager` is configured and this contract is registered,
-     * reads the repository-backed state (offline-first, kept fresh by the
-     * contract watcher). Otherwise falls back to a direct indexer query.
+     * Activity is reported from subscription on — coins that predate it are not replayed. After
+     * subscribing, and on every `connection_reset` (the manager re-syncs silently), read stored
+     * state with {@link getVtxos}.
      *
-     * Both branches refuse a spent or unilaterally exited output. They are not
-     * otherwise interchangeable: the fallback asks `spendableOnly`, which also
-     * drops swept coins — the manager branch keeps those.
+     * @example
+     * ```typescript
+     * const spent = await htlc.on("vtxo_spent", (e) => console.log(e.vtxos));
+     * const reset = await htlc.on("connection_reset", async () => reconcile(await htlc.getVtxos()));
+     * spent.off();
+     * ```
+     */
+    on<T extends ArkadeContractEventType>(type: T, callback: (event: ArkadeContractEvent<T>) => void | Promise<void>): Promise<ArkadeContractSubscription>;
+    /**
+     * Every stored VTXO of this contract, spent ones included (`getUtxos` hides those), as the
+     * contract manager last synced them. The recovery read for {@link on}. Empty when the
+     * contract is not registered.
+     */
+    getVtxos(): Promise<ExtendedContractVtxo[]>;
+    private requireManager;
+    /**
+     * Spendable VTXOs locked by this contract: repository-backed when registered with a
+     * `contractManager`, otherwise a direct indexer query. Both drop spent and unrolled outputs;
+     * only the indexer branch (`spendableOnly`) also drops swept coins.
      */
     getUtxos(): Promise<VirtualCoin[]>;
     /** Total spendable balance (requires an indexer). */
@@ -5884,6 +5733,7 @@ declare class ArkadeTransactionBuilder {
     private readonly outputs;
     private readonly fundingCoins;
     private readonly assetSpecs;
+    private readonly extraPackets;
     private coin?;
     private changeScript?;
     /** @internal */
@@ -5896,6 +5746,8 @@ declare class ArkadeTransactionBuilder {
     fund(coins: ArkTxInput[]): this;
     /** Transfer an asset group: which inputs supply it and which outputs receive it. */
     withAsset(spec: AssetSpec): this;
+    /** Add an extension packet; reusing the asset or emulator packet's type fails at build. */
+    withPacket(packet: ExtensionPacket): this;
     /** Destination for any surplus (inputs − outputs). Required when the spend is not exact. */
     change(script: Uint8Array): this;
     /** Add an output — `(script, amount)` or a list of outputs. */
@@ -5944,9 +5796,14 @@ declare const index_ArkadeArgType: typeof ArkadeArgType;
 declare const index_ArkadeArgValue: typeof ArkadeArgValue;
 type index_ArkadeBatchInput = ArkadeBatchInput;
 type index_ArkadeConnectOptions = ArkadeConnectOptions;
+type index_ArkadeConnectProviderOptions = ArkadeConnectProviderOptions;
+type index_ArkadeConnectServiceOptions = ArkadeConnectServiceOptions;
 type index_ArkadeContract<P extends Program = Program> = ArkadeContract<P>;
 declare const index_ArkadeContract: typeof ArkadeContract;
+type index_ArkadeContractEvent<T extends ArkadeContractEventType = ArkadeContractEventType> = ArkadeContractEvent<T>;
+type index_ArkadeContractEventType = ArkadeContractEventType;
 declare const index_ArkadeContractParams: typeof ArkadeContractParams;
+type index_ArkadeContractSubscription = ArkadeContractSubscription;
 type index_ArkadeExtendedCoin = ArkadeExtendedCoin;
 type index_ArkadeExtendedVirtualCoin = ArkadeExtendedVirtualCoin;
 declare const index_ArkadeFunction: typeof ArkadeFunction;
@@ -5957,6 +5814,7 @@ type index_ArkadeScriptOP = ArkadeScriptOP;
 type index_ArkadeScriptType = ArkadeScriptType;
 declare const index_ArkadeSegment: typeof ArkadeSegment;
 type index_ArkadeServerProvider = ArkadeServerProvider;
+declare const index_ArkadeService: typeof ArkadeService;
 type index_ArkadeSpendResult = ArkadeSpendResult;
 type index_ArkadeTransactionBuilder = ArkadeTransactionBuilder;
 declare const index_ArkadeTransactionBuilder: typeof ArkadeTransactionBuilder;
@@ -5964,6 +5822,7 @@ declare const index_AsmToken: typeof AsmToken;
 type index_AssetSpec = AssetSpec;
 type index_CallableFunctions = CallableFunctions;
 declare const index_CompiledProgramFunction: typeof CompiledProgramFunction;
+type index_ContractArtifact = ContractArtifact;
 type index_ContractFunctions<P extends Program> = ContractFunctions<P>;
 declare const index_InputDef: typeof InputDef;
 declare const index_InputRef: typeof InputRef;
@@ -5972,11 +5831,14 @@ declare const index_OPCODE_NAMES: typeof OPCODE_NAMES;
 declare const index_OPCODE_VALUES: typeof OPCODE_VALUES;
 declare const index_Program: typeof Program;
 declare const index_ProgramKeys: typeof ProgramKeys;
+declare const index_ResolvedArkadeService: typeof ResolvedArkadeService;
 declare const index_SUPPORTED_PROGRAM_VERSION: typeof SUPPORTED_PROGRAM_VERSION;
 declare const index_Script: typeof Script;
 declare const index_ScriptType: typeof ScriptType;
 declare const index_SignerRef: typeof SignerRef;
 declare const index_TapscriptSegment: typeof TapscriptSegment;
+declare const index_TweakedSigner: typeof TweakedSigner;
+declare const index_UnsupportedProgramVersionError: typeof UnsupportedProgramVersionError;
 type index_Utxo = Utxo;
 declare const index_WitnessRef: typeof WitnessRef;
 declare const index_arkadeScriptHash: typeof arkadeScriptHash;
@@ -5989,7 +5851,10 @@ declare const index_deserializeArkadeContractParams: typeof deserializeArkadeCon
 declare const index_fromASM: typeof fromASM;
 declare const index_getOpcodeName: typeof getOpcodeName;
 declare const index_getOpcodeValue: typeof getOpcodeValue;
+declare const index_isContractArtifact: typeof isContractArtifact;
 declare const index_parseArtifact: typeof parseArtifact;
+declare const index_programFromArtifact: typeof programFromArtifact;
+declare const index_resolveArkadeService: typeof resolveArkadeService;
 declare const index_resolveAsm: typeof resolveAsm;
 declare const index_serializeArkadeContractParams: typeof serializeArkadeContractParams;
 declare const index_stringifyArtifact: typeof stringifyArtifact;
@@ -5997,7 +5862,7 @@ declare const index_toASM: typeof toASM;
 declare const index_validateProgram: typeof validateProgram;
 declare const index_witnessRefToBytes: typeof witnessRefToBytes;
 declare namespace index {
-  export { index_ARKADE_OP as ARKADE_OP, index_ARKADE_OPCODES as ARKADE_OPCODES, index_ARKADE_OPCODE_NAMES as ARKADE_OPCODE_NAMES, index_ARKADE_OPCODE_VALUES as ARKADE_OPCODE_VALUES, index_ARKADE_OPS as ARKADE_OPS, index_Arkade as Arkade, index_ArkadeArgType as ArkadeArgType, index_ArkadeArgValue as ArkadeArgValue, type index_ArkadeBatchInput as ArkadeBatchInput, type index_ArkadeConnectOptions as ArkadeConnectOptions, index_ArkadeContract as ArkadeContract, index_ArkadeContractParams as ArkadeContractParams, type index_ArkadeExtendedCoin as ArkadeExtendedCoin, type index_ArkadeExtendedVirtualCoin as ArkadeExtendedVirtualCoin, index_ArkadeFunction as ArkadeFunction, index_ArkadeParamValue as ArkadeParamValue, index_ArkadeProgramScript as ArkadeProgramScript, index_ArkadeScript as ArkadeScript, type index_ArkadeScriptOP as ArkadeScriptOP, type index_ArkadeScriptType as ArkadeScriptType, index_ArkadeSegment as ArkadeSegment, type index_ArkadeServerProvider as ArkadeServerProvider, type index_ArkadeSpendResult as ArkadeSpendResult, index_ArkadeTransactionBuilder as ArkadeTransactionBuilder, index_AsmToken as AsmToken, type index_AssetSpec as AssetSpec, bignum as BigNum, type index_CallableFunctions as CallableFunctions, index_CompiledProgramFunction as CompiledProgramFunction, type index_ContractFunctions as ContractFunctions, index_InputDef as InputDef, index_InputRef as InputRef, index_OP as OP, index_OPCODE_NAMES as OPCODE_NAMES, index_OPCODE_VALUES as OPCODE_VALUES, index_Program as Program, index_ProgramKeys as ProgramKeys, index_SUPPORTED_PROGRAM_VERSION as SUPPORTED_PROGRAM_VERSION, index_Script as Script, index_ScriptType as ScriptType, index_SignerRef as SignerRef, index_TapscriptSegment as TapscriptSegment, type index_Utxo as Utxo, index_WitnessRef as WitnessRef, index_arkadeScriptHash as arkadeScriptHash, index_arkadeWitnessHash as arkadeWitnessHash, index_asmToBytes as asmToBytes, index_bytesToASM as bytesToASM, index_computeArkadeScriptPublicKey as computeArkadeScriptPublicKey, index_createArkadeBatchHandler as createArkadeBatchHandler, index_deserializeArkadeContractParams as deserializeArkadeContractParams, index_fromASM as fromASM, index_getOpcodeName as getOpcodeName, index_getOpcodeValue as getOpcodeValue, index_parseArtifact as parseArtifact, index_resolveAsm as resolveAsm, index_serializeArkadeContractParams as serializeArkadeContractParams, index_stringifyArtifact as stringifyArtifact, index_toASM as toASM, index_validateProgram as validateProgram, index_witnessRefToBytes as witnessRefToBytes };
+  export { index_ARKADE_OP as ARKADE_OP, index_ARKADE_OPCODES as ARKADE_OPCODES, index_ARKADE_OPCODE_NAMES as ARKADE_OPCODE_NAMES, index_ARKADE_OPCODE_VALUES as ARKADE_OPCODE_VALUES, index_ARKADE_OPS as ARKADE_OPS, index_Arkade as Arkade, index_ArkadeArgType as ArkadeArgType, index_ArkadeArgValue as ArkadeArgValue, type index_ArkadeBatchInput as ArkadeBatchInput, type index_ArkadeConnectOptions as ArkadeConnectOptions, type index_ArkadeConnectProviderOptions as ArkadeConnectProviderOptions, type index_ArkadeConnectServiceOptions as ArkadeConnectServiceOptions, index_ArkadeContract as ArkadeContract, type index_ArkadeContractEvent as ArkadeContractEvent, type index_ArkadeContractEventType as ArkadeContractEventType, index_ArkadeContractParams as ArkadeContractParams, type index_ArkadeContractSubscription as ArkadeContractSubscription, type index_ArkadeExtendedCoin as ArkadeExtendedCoin, type index_ArkadeExtendedVirtualCoin as ArkadeExtendedVirtualCoin, index_ArkadeFunction as ArkadeFunction, index_ArkadeParamValue as ArkadeParamValue, index_ArkadeProgramScript as ArkadeProgramScript, index_ArkadeScript as ArkadeScript, type index_ArkadeScriptOP as ArkadeScriptOP, type index_ArkadeScriptType as ArkadeScriptType, index_ArkadeSegment as ArkadeSegment, type index_ArkadeServerProvider as ArkadeServerProvider, index_ArkadeService as ArkadeService, type index_ArkadeSpendResult as ArkadeSpendResult, index_ArkadeTransactionBuilder as ArkadeTransactionBuilder, index_AsmToken as AsmToken, type index_AssetSpec as AssetSpec, bignum as BigNum, type index_CallableFunctions as CallableFunctions, index_CompiledProgramFunction as CompiledProgramFunction, type index_ContractArtifact as ContractArtifact, type index_ContractFunctions as ContractFunctions, index_InputDef as InputDef, index_InputRef as InputRef, index_OP as OP, index_OPCODE_NAMES as OPCODE_NAMES, index_OPCODE_VALUES as OPCODE_VALUES, index_Program as Program, index_ProgramKeys as ProgramKeys, index_ResolvedArkadeService as ResolvedArkadeService, index_SUPPORTED_PROGRAM_VERSION as SUPPORTED_PROGRAM_VERSION, index_Script as Script, index_ScriptType as ScriptType, index_SignerRef as SignerRef, index_TapscriptSegment as TapscriptSegment, index_TweakedSigner as TweakedSigner, index_UnsupportedProgramVersionError as UnsupportedProgramVersionError, type index_Utxo as Utxo, index_WitnessRef as WitnessRef, index_arkadeScriptHash as arkadeScriptHash, index_arkadeWitnessHash as arkadeWitnessHash, index_asmToBytes as asmToBytes, index_bytesToASM as bytesToASM, index_computeArkadeScriptPublicKey as computeArkadeScriptPublicKey, index_createArkadeBatchHandler as createArkadeBatchHandler, index_deserializeArkadeContractParams as deserializeArkadeContractParams, index_fromASM as fromASM, index_getOpcodeName as getOpcodeName, index_getOpcodeValue as getOpcodeValue, index_isContractArtifact as isContractArtifact, index_parseArtifact as parseArtifact, index_programFromArtifact as programFromArtifact, index_resolveArkadeService as resolveArkadeService, index_resolveAsm as resolveAsm, index_serializeArkadeContractParams as serializeArkadeContractParams, index_stringifyArtifact as stringifyArtifact, index_toASM as toASM, index_validateProgram as validateProgram, index_witnessRefToBytes as witnessRefToBytes };
 }
 
 /** Known BIP21 parameters including Arkade-specific extensions. */
@@ -6075,23 +5940,14 @@ interface PaymentHandle {
     }): Promise<RouteResult>;
 }
 /**
- * A priced route. The three amounts are **receiver-exact** and mean the same
- * thing on every rail, so `options()` can be ranked on cost and a rail swapped
- * without changing what the recipient gets:
+ * A priced route. The amounts are **receiver-exact** on every rail, so options rank on cost and
+ * rails swap without changing what the recipient gets. Rails whose primitive *deducts* its fee
+ * (collaborative exit) gross the amount up; a rail that can't (it doesn't choose the fee) flags
+ * it via `claimFeeDeductedFromPayout`.
  *
- * - `amount` — sats delivered **to the recipient**.
- * - `fee` — sats charged **on top**, by the rail and its counterparty.
- * - `total` — `amount + fee`; the sats that leave the wallet.
- *
- * Rails whose underlying primitive *deducts* its fee (the collaborative exit)
- * gross the amount up to honour this; rails that add it on top pass it through.
- * A rail that does not perform the deducting spend cannot gross up to a fee it
- * never chooses, and flags that instead: see `claimFeeDeductedFromPayout`.
- *
- * `fee` is a pre-send estimate wherever the true cost is only fixed later: the
- * collaborative exit does not include the per-input intent fees, which depend
- * on the VTXO selection made at settlement. Treat it as a display and ranking
- * figure, not a guarantee.
+ * `fee` is an estimate where cost is fixed later: the collaborative exit omits per-input intent
+ * fees unless {@link PaymentRequest.selectedVtxos} is named. A display/ranking figure, not a
+ * guarantee.
  */
 interface RouteQuote {
     railId: string;
@@ -6102,31 +5958,18 @@ interface RouteQuote {
     /** `amount + fee` — what leaves the wallet. */
     total: number;
     /**
-     * Unix seconds after which the counterparty stops honouring this quote.
-     *
-     * Absent means "nothing to observe", not "never expires": a rail with no
-     * counterparty and no quote book — an Arkade transfer, an asset transfer, a
-     * collaborative exit — has no validity to state. A caller holding a quote
-     * across user think-time should read absence as "no check possible", and must
-     * still expect {@link send} to refuse either way: the swap rails re-check
-     * validity there, which is the only point that can judge it against the
-     * moment of spending.
+     * Unix seconds after which the counterparty stops honouring this quote. Absent means "no
+     * check possible" (rails without a counterparty), not "never expires"; {@link send} may
+     * still refuse, since swap rails re-check validity at spend time.
      */
     validUntil?: number;
     /**
-     * @experimental The asset shape is provisional. The v2 swap client models
-     * assets as `give`/`take`/`amountOn` over `AssetRef`, and the two
-     * vocabularies are expected to converge on v0.5; do not treat this field as
-     * stable 0.4.x API.
-     *
-     * The asset view; absent means BTC only. The sats fields keep their
-     * meaning — an asset rides a sats-carrying output, so `amount` is the
-     * carrier, not zero.
+     * @experimental The asset shape is provisional, expected to converge with the v2 swap
+     * client's `give`/`take`/`amountOn` over `AssetRef` in v0.5; not stable 0.4.x API.
      *
-     * A pair, not a triple: on a cross-asset route these name DIFFERENT
-     * assets, so `total = amount + fee` cannot hold across the two units —
-     * which forces the purchase price into `fee`. Prefer `assets.spent` for a
-     * cost display.
+     * The asset view; absent means BTC only. `amount` stays the sats carrier, not zero. On a
+     * cross-asset route `delivered`/`spent` are different assets, so the purchase price lands in
+     * `fee`; prefer `assets.spent` for a cost display.
      */
     assets?: {
         delivered: Asset;
@@ -6164,6 +6007,13 @@ interface PaymentRequest {
      *  Additive: an asset transfer also moves sats, so a 500 USDX request
      *  legitimately has both. A rail that cannot deliver assets must REFUSE. */
     assets?: Asset[];
+    /**
+     * Spend exactly these (normalized) virtual outputs, as {@link SendParams.selectedVtxos}:
+     * ungated like `settle({ inputs })`, and a shortfall is an error, not a top-up. Only rails
+     * spending the wallet's own coins (`ark`, `ark-asset`, `onchain`) can honour it;
+     * counterparty-funded rails must REFUSE, not ignore it.
+     */
+    selectedVtxos?: NormalizedExtendedVirtualCoin[];
 }
 /** A payment rail — registered by id, mirrors the ActivityRegistry resolver shape. */
 interface PaymentRail {
@@ -6196,10 +6046,11 @@ declare const isLightningInvoice: (raw: string) => boolean;
 /**
  * True for an LNURL or a Lightning address (`user@host`).
  *
- * TODO(lnurl): no rail consumes this yet — LNURL / Lightning-address routing is
- * planned future work. The predicate is exported ahead of the rail so consumers
- * can classify these targets today; until the rail lands, `route()` throws
- * "no rail for" on them. Keep the export (do not flag as unused).
+ * No rail here consumes it, and that is the layering rather than a gap:
+ * routing an LNURL needs an LNURL client, so the rails ship from
+ * `@arkade-os/lnurl-client/arkade` (`lnurlRails`) and are registered by the
+ * app, as the solver rails from `@arkade-os/swap` are. With none registered,
+ * `route()` throws "no rail for" on these targets.
  */
 declare const isLnurl: (raw: string) => boolean;
 /** True for a bech32 (segwit) or base58 (legacy) Bitcoin address, any network —
@@ -6236,6 +6087,11 @@ declare function assetsOf(req: PaymentRequest): Asset[];
 /** For a BTC-only rail: refusing is what leaves the router free to rank an
  *  asset-capable one, instead of paying the carrier and dropping the asset. */
 declare function assertNoAssets(railId: string, req: PaymentRequest): void;
+/** The inputs a request names. An EMPTY array is still a selection, covering nothing. */
+declare function selectionOf(req: PaymentRequest): NormalizedExtendedVirtualCoin[] | undefined;
+/** For a rail whose counterparty funds the spend: ignoring a named input set
+ *  would spend coins the caller had promised elsewhere, so refuse instead. */
+declare function assertNoSelection(railId: string, req: PaymentRequest): void;
 /** Exactly one: `Wallet.send` takes a list because one output can carry
  *  several, but a routed PAYMENT is one thing being paid. */
 declare function resolveAssetAmount(railId: string, req: PaymentRequest): Asset;
@@ -6314,12 +6170,15 @@ declare const walletFeeSource: (wallet: Wallet) => () => Promise<FeeInfo>;
  * and offboards VTXOs to the address via {@link Ramps.offboard}, which owns
  * fee-aware coin selection, dust-safe change, and settlement.
  *
- * `offboard` deducts its fee from the amount it is handed, so the rail grosses
- * the amount up first: the recipient receives exactly `quote.amount`, matching
- * the receiver-exact semantics of every other rail (see {@link RouteQuote}).
- * `quote.total` is the offboard amount; the per-input intent fees `offboard`
- * shaves off the selected VTXOs are additional and depend on the selection, so
- * they are not part of the quote.
+ * The exit fee is priced on the DESTINATION output — the one arkd charges for —
+ * and met from the balance, so the recipient receives exactly `quote.amount`
+ * (see {@link RouteQuote}). {@link Ramps.offboardExact} carries that; the
+ * gross-up this rail used to do could only approximate it.
+ *
+ * A request naming `selectedVtxos` offboards exactly those — so the exit need not
+ * sweep the whole off-chain balance into one change output — and only then does
+ * the quote carry the per-input intent fees: unselected, the coins are chosen
+ * later at settlement and there is nothing here to price.
  *
  * An explicit amount is mandatory. To sweep the full balance, call
  * `Ramps.offboard(address, feeInfo)` directly — the router has no amountless path.
@@ -6389,9 +6248,7 @@ declare function sequenceToTimelock(sequence: number): RelativeTimelock;
 declare function toXOnly(key: Uint8Array, label?: string): Uint8Array;
 
 declare const buildVersion = "0.9.9";
-/**
- * The SDK's own version string, sourced from package.json
- */
+/** The SDK's own version string, sourced from package.json */
 declare const sdkVersion: string;
 /**
  * Wraps a transport-level `fetch` rejection (DNS failure, connection refused,
@@ -6410,12 +6267,9 @@ declare class FetchError extends Error {
     });
 }
 /**
- * Deadline applied to a read that carries no `AbortSignal` of its own.
- *
- * `fetch` has no default timeout, so a connection the network dropped silently
- * stays pending until the runtime gives up — and every bound built on top of it
- * waits with it. A retry ladder, a bounded queue or a mutex only work if the
- * call underneath them terminates.
+ * Deadline for a read that carries no `AbortSignal` of its own. `fetch` has no default timeout,
+ * so a silently dropped connection stays pending, and every retry ladder, queue or mutex built on
+ * top of it waits with it.
  */
 declare const READ_TIMEOUT_MS = 30000;
 
@@ -6478,46 +6332,22 @@ interface ManagedConnection extends AsyncDisposable {
     /**
      * The open connection, opening it on first call.
      *
-     * Call this once per operation and use the handle for the transaction you
-     * start right away — never store it on the repository, and never carry it
-     * across an `await`. The connection can be closed underneath you at any
-     * time (a `versionchange` from another tab, eviction, "clear site data"),
-     * after which every transaction on that handle throws `InvalidStateError`;
-     * a later `get()` transparently reopens, but only for callers that ask
-     * again. Holding the resolved database is exactly the defect this type
-     * exists to remove.
-     *
-     * ## The dispose boundary
+     * Call once per operation and use the handle for the transaction you start right away —
+     * never store it or carry it across an `await`. It can be closed underneath you at any time
+     * (`versionchange` from another tab, eviction, "clear site data"), after which every
+     * transaction on it throws `InvalidStateError`; a later `get()` transparently reopens.
      *
-     * `get()` is valid only before `[Symbol.asyncDispose]`. Afterwards it
-     * rejects with {@link ConnectionDisposedError}, permanently: dispose has
-     * released this connection's single reference, and reopening would take a
-     * refcount nothing is left to release. Disposal is final by design — there
-     * is no revive; construct a new repository, which constructs a new
-     * connection, instead.
-     *
-     * Dispose neither awaits nor cancels work already in flight. A transaction
-     * started just before it can abort when the underlying handle closes, and
-     * an in-flight `get()` may resolve to a database that is closing. So
-     * sequence disposal after the operations you care about have settled —
-     * `await` the repository's outstanding calls first — rather than racing it
-     * against them.
-     *
-     * Callers must not close the database themselves; the reference this
-     * connection holds is released by its own dispose, once.
+     * After `[Symbol.asyncDispose]` it rejects with {@link ConnectionDisposedError}, permanently:
+     * reopening would take a refcount nothing releases, so construct a new repository instead.
+     * Dispose neither awaits nor cancels in-flight work, so `await` outstanding repository calls
+     * before disposing. Callers must not close the database themselves.
      */
     get(): Promise<IDBDatabase>;
 }
 /**
- * Forget-and-reopen around {@link openDatabase}, shared by every IndexedDB
- * repository. Caching the resolved `IDBDatabase` is the defect this exists to
- * remove: once the manager closes on `versionchange`, every later transaction on
- * that handle throws `InvalidStateError` with no path back.
- *
- * Opens nothing until the first {@link ManagedConnection.get} — repositories
- * construct their storage in their own constructors, and an eager open would
- * move the "IndexedDB is not available in this environment" throw to
- * construction time.
+ * Forget-and-reopen around {@link openDatabase}, shared by every IndexedDB repository: a cached
+ * `IDBDatabase` throws `InvalidStateError` forever once the manager closes it on `versionchange`.
+ * Lazy, so the "IndexedDB is not available" throw stays out of repository constructors.
  */
 declare function createManagedConnection(dbName: string, version: number, initDatabase: (db: IDBDatabase, oldVersion: number, transaction: IDBTransaction | null) => void): ManagedConnection;
 
@@ -6591,6 +6421,7 @@ declare class AssetManager extends ReadonlyAssetManager implements IAssetManager
      * ```
      */
     issue(params: IssuanceParams): Promise<IssuanceResult>;
+    private issueWith;
     /**
      * Reissue more units of an existing asset.
      * Requires ownership of the control asset.
@@ -6609,6 +6440,7 @@ declare class AssetManager extends ReadonlyAssetManager implements IAssetManager
      * ```
      */
     reissue(params: ReissuanceParams): Promise<string>;
+    private reissueWith;
     /**
      * Burn assets.
      * @param params - Parameters for burning
@@ -6625,6 +6457,7 @@ declare class AssetManager extends ReadonlyAssetManager implements IAssetManager
      * ```
      */
     burn(params: BurnParams): Promise<string>;
+    private burnWith;
 }
 
-export { ARKADE_MAGIC, ARKADE_SALTED_PREIMAGE_TAG, ARKADE_SWAP_PREIMAGE_TAG, ASSET_CARRIER_SATS, Activity, ActivityRegistry, AddressAllocationCapable, AmbiguousRouteError, type AnchorBumper, ArkAddress, ArkIntent, ArkNote, ArkProvider, type ArkPsbtFieldCoder, ArkPsbtFieldKey, ArkPsbtFieldKeyType, ArkTransaction, type ArkTxInput, type ArkadeBatchInput, ArkadeBroadcaster, ArkadeCash, ArkadeContractParams, type ArkadeExtendedCoin, type ArkadeExtendedVirtualCoin, ArkadeInfo, ArkadeReader, Asset, AssetDetails, AssetManager, BIP21, BIP21Error, type BIP21Params, type BIP21ParseResult, BIP322, BLOCKED_UPGRADE_TIMEOUT_MS, Batch, BatchExpiryPolicy, BurnParams, CSVMultisigTapscript, CachingArkProvider, ChainTx, Coin, ConditionWitness, ConnectionDisposedError, type ConnectorTreeNode, Contract, ContractEvent, ContractRepository, ContractSyncState, ContractWatcherConfig, ContractWithVtxos, CosignerPublicKey, CreateContractParams, DEFAULT_MESSAGE_TIMEOUTS, DatabaseUpgradeBlockedError, DefaultVtxo, DelegateInfo, DelegateNotConfiguredError, DescriptorIdentity, type DescriptorIdentityOptions, type DescriptorOptions, type DescriptorSigner, DescriptorSigningProviderMissingError, type DeterministicSigner, DustChangeError, ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, type BlockHeader as ElectrumBlockHeader, ElectrumOnchainProvider, type TransactionHistory as ElectrumTransactionHistory, type Unspent as ElectrumUnspent, type EmulatorEntry, type EmulatorInfo, EmulatorPacket, type EmulatorProvider, EncodedVtxoScript, Estimator, type ExcludableVtxo, type ExecutorEvent, type ExecutorOptions, type ExitDelay, type ExitFeeWallet, type ExitMode, type ExitOptions, type ExitPackage, type ExitQuote, type ExitStep, type ExitTotals, type ExitVtxoInfo, ExplorerTransaction, ExtendedCoin, ExtendedVirtualCoin, Extension, ExtensionNotFoundError, type ExtensionPacket, FeeAmount, FeeInfo, FeeOutput, FetchError, GetArkadeInfoOptions, GetNewAddressesOptions, GetVtxosFilter, GetVtxosOptions, HDAllocationCapable, HDDescriptorProvider, type HDDeterministicSignCapable, HDWalletCapable, IAssetManager, IContractManager, IDelegateManager, IReadonlyAssetManager, IReadonlyWallet, IVtxoManager, IWallet, Identity, InMemoryContractRepository, InMemoryIntentRepository, InMemoryVirtualTxRepository, InMemoryWalletRepository, IndexedDBContractRepository, IndexedDBIntentRepository, IndexedDBVirtualTxRepository, IndexedDBWalletRepository, IndexerProvider, Intent, IntentFeeConfig, IntentFilter, IntentRepository, IssuanceParams, IssuanceResult, MESSAGE_BUS_INITIALIZING, MESSAGE_BUS_NOT_INITIALIZED, type ManagedConnection, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, type MessageHandler, type MessageTimeouts, MigrationGlobalSkipReason, MigrationLegSkipReason, MissingSigningDescriptorError, MnemonicIdentity, type MnemonicOptions, Network, NetworkName, type NetworkOptions, NewAddress, NormalizedVtxoPage, OffchainInput, type OffchainTx, type OnExitObserved, OnchainInput, OnchainProvider, OnchainWallet, Outpoint, P2A, PaginationOptions, type ParsedArkContract, PathContext, PathSelection, type PaymentHandle, type PaymentOption, type PaymentRail, type PaymentRequest, PaymentRouter, type PaymentStatus, PrevArkTxField, PrevoutTxField, ProviderConnectionState, type ProvisionedClaimSecret, type ProvisionedKey, READ_TIMEOUT_MS, Ramps, ReadonlyAssetManager, ReadonlyDescriptorIdentity, ReadonlyIdentity, ReadonlySingleKey, ReadonlyWallet, ReadonlyWalletError, Recipient, ReissuanceParams, RelativeTimelock, RenewVtxosOptions, type RequestEnvelope, type ResponseEnvelope, RestEmulatorProvider, type RouteQuote, type RouteResult, type RouterContext, type RouterPreferences, SeedIdentity, type SeedIdentityOptions, SendBitcoinParams, SendParams, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, type ServiceWorkerWalletMode, SettleParams, SettlementConfig, SettlementEvent, SignedIntent, SignerSession, SignerStatus, SingleKey, Status, StorageConfig, TapLeafScript, Transaction, TreeNonces, TreePartialSigs, TxNotificationEvent, TxTree, TxWeightEstimator, UnannotatableInputError, UnilateralExit, UnknownPacket, Unroll, type VSize, type VerifyServerSignatures, VirtualCoin, VirtualTx, VirtualTxRepository, VtxoBranch, type VtxoExclusion, VtxoScript, VtxoTaprootTree, VtxoTreeExpiry, Wallet, WalletBalance, WalletCannotSignError, WalletMessageHandler, WalletNotInitializedError, WalletRepository, type WalletRestoreHook, WatchedScript, WsElectrumChainSource, adoptContractDescriptor, arkAssetRail, arkRail, arkTarget, index as arkade, assembleBtcdTaprootTree, assertFinalCommitmentMatchesValidated, assertNoAssets, assertSendableAmount, assertSubmittedArkTxid, index$1 as asset, assetsOf, awaitTransaction, btcTarget, buildForfeitTx, buildOffchainTx, buildPreimageMessage, buildSaltedPreimageMessage, buildVersion, claimWithPreimageIdentity, closeDatabase, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, contractPreimage, contractSigner, createAssetPacket, createDefaultPaymentRouter, createManagedConnection, decodeArkContract, deleteByIndex, deriveDescriptorLeafCompressedPubKey, deriveDescriptorLeafPubKey, deserializeExitPackage, encodeArkContract, exitObserverFor, gateExclusion, gatedContracts, getAllByIndexValues, getArkPsbtFields, hasBoardingTxExpired, identityDescriptor, invoiceTarget, isArkContract, isBtcAddress, isCltvSatisfied, isContractGenericallySpendable, isCsvSpendable, isDeterministicSigner, isHDDeterministicSignCapable, isLightningInvoice, isLnurl, isMessageBusInitializingError, isMessageBusNotInitializedError, isPerArtifactDescriptor, isRetryableProviderError, isValidArkAddress, logExcludedVtxos, makeHandle, matchServerCheckpoints, normalizeToDescriptor, notifyExitObserved, onchainRail, openDatabase, outpointExclusion, outpointReasons, parseHDDescriptor, promisifyRequest, provisionClaimSecret, provisionRefundKey, registerWalletRestoreHook, resolveAssetAmount, resolveSendAmount, sdkVersion, selectCoinsWithAsset, sequenceToTimelock, serializeExitPackage, setArkPsbtField, setupServiceWorker, signAndSubmitOffchainTx, timelockToSequence, toXOnly, tryResolveSendAmount, validateBatchRecipients, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, walletFeeSource };
+export { ARKADE_MAGIC, ARKADE_SALTED_PREIMAGE_TAG, ARKADE_SWAP_PREIMAGE_TAG, ASSET_CARRIER_SATS, Activity, ActivityRegistry, AddressAllocationCapable, AmbiguousRouteError, type AnchorBumper, ArkAddress, ArkIntent, ArkNote, ArkProvider, type ArkPsbtFieldCoder, ArkPsbtFieldKey, ArkPsbtFieldKeyType, ArkTransaction, type ArkTxInput, Arkade, type ArkadeBatchInput, ArkadeBroadcaster, ArkadeCash, ArkadeContractParams, type ArkadeExtendedCoin, type ArkadeExtendedVirtualCoin, ArkadeInfo, ArkadeReader, ArkadeService, Asset, AssetDetails, AssetManager, BIP21, BIP21Error, type BIP21Params, type BIP21ParseResult, BIP322, BLOCKED_UPGRADE_TIMEOUT_MS, Batch, BatchExpiryPolicy, BurnParams, CSVMultisigTapscript, CachingArkProvider, ChainTx, Coin, ConditionWitness, ConnectionDisposedError, Contract, ContractEvent, ContractFilter, ContractRepository, ContractSyncState, ContractVtxoEvent, ContractWatcherConfig, ContractWithVtxos, CosignerPublicKey, CreateContractParams, DEFAULT_MESSAGE_TIMEOUTS, DatabaseUpgradeBlockedError, DefaultVtxo, DelegateInfo, DelegateNotConfiguredError, DescriptorIdentity, type DescriptorIdentityOptions, type DescriptorOptions, DescriptorProvider, type DescriptorSigner, DescriptorSigningProviderMissingError, DescriptorSigningRequest, type DeterministicSigner, DustChangeError, ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, type BlockHeader as ElectrumBlockHeader, ElectrumOnchainProvider, type TransactionHistory as ElectrumTransactionHistory, type Unspent as ElectrumUnspent, type EmulatorEntry, EmulatorPacket, EmulatorProvider, EncodedVtxoScript, Estimator, type ExcludableVtxo, type ExecutorEvent, type ExecutorOptions, type ExitDelay, type ExitFeeWallet, type ExitMode, type ExitOptions, type ExitPackage, type ExitQuote, type ExitStep, type ExitTotals, type ExitVtxoInfo, ExplorerTransaction, ExtendedCoin, ExtendedContractVtxo, ExtendedVirtualCoin, Extension, ExtensionNotFoundError, type ExtensionPacket, FeeAmount, FeeInfo, FeeOutput, FetchError, GetArkadeInfoOptions, GetNewAddressesOptions, GetSpendableVtxosFilter, GetVtxosFilter, GetVtxosOptions, HDAllocationCapable, HDDescriptorProvider, type HDDeterministicSignCapable, HDWalletCapable, IAssetManager, IContractManager, IDelegateManager, IReadonlyAssetManager, IReadonlyWallet, IVtxoManager, IWallet, Identity, InMemoryContractRepository, InMemoryIntentRepository, InMemoryVirtualTxRepository, InMemoryWalletRepository, IndexedDBContractRepository, IndexedDBIntentRepository, IndexedDBVirtualTxRepository, IndexerProvider, InputExpiryFloor, Intent, IntentFeeConfig, IntentPageFilter, IntentRepository, IssuanceParams, IssuanceResult, MESSAGE_BUS_INITIALIZING, MESSAGE_BUS_NOT_INITIALIZED, type ManagedConnection, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, type MessageHandler, type MessageTimeouts, MigrationGlobalSkipReason, MigrationLegSkipReason, MissingSigningDescriptorError, MnemonicIdentity, type MnemonicOptions, Network, NetworkName, type NetworkOptions, NewAddress, NormalizedExtendedVirtualCoin, NormalizedVtxoPage, OffchainInput, type OffchainTx, type OnExitObserved, OnchainInput, OnchainProvider, OnchainWallet, Outpoint, OversizedChangeError, P2A, PageRequest, PageResult, PaginationOptions, type ParsedArkContract, PathContext, PathSelection, type PaymentHandle, type PaymentOption, type PaymentRail, type PaymentRequest, PaymentRouter, type PaymentStatus, PrevArkTxField, PrevoutTxField, ProviderConnectionState, type ProvisionedClaimSecret, type ProvisionedKey, READ_TIMEOUT_MS, Ramps, ReadonlyAssetManager, ReadonlyDescriptorIdentity, ReadonlyIdentity, ReadonlySingleKey, ReadonlyWallet, ReadonlyWalletError, Recipient, ReissuanceParams, RelativeTimelock, RenewVtxosOptions, type RequestEnvelope, type ResponseEnvelope, type RouteQuote, type RouteResult, type RouterContext, type RouterPreferences, ScriptVtxoCursor, ScriptVtxoPageOptions, SeedIdentity, type SeedIdentityOptions, SendBitcoinParams, SendDeadlineExceededError, SendParams, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, type ServiceWorkerWalletMode, SettleParams, SettlementConfig, SettlementEvent, SignedIntent, SignerSession, SignerStatus, SingleKey, StaticDescriptorProvider, Status, StorageConfig, StoredVtxo, TapLeafScript, Transaction, TransactionHistoryPageCursor, TransactionHistoryPageFilter, TreeNonces, TreePartialSigs, TxNotificationEvent, TxTree, TxWeightEstimator, UnannotatableInputError, UnilateralExit, UnknownPacket, Unroll, UnsupportedProgramVersionError, type VSize, type VerifyServerSignatures, VirtualCoin, VirtualTx, VirtualTxRepository, VtxoBranch, type VtxoExclusion, VtxoScript, VtxoTaprootTree, VtxoTreeExpiry, Wallet, WalletBalance, WalletCannotSignError, WalletMessageHandler, WalletNotInitializedError, WalletRepository, type WalletRestoreHook, WatchedScript, WsElectrumChainSource, adoptContractDescriptor, arkAssetRail, arkRail, arkTarget, index as arkade, assembleBtcdTaprootTree, assertFinalCommitmentMatchesValidated, assertNoAssets, assertNoSelection, assertNonNegativeMs, assertSendDeadline, assertSendableAmount, assertSubmittedArkTxid, assertTimerMs, assertValidServerUnrollScript, index$1 as asset, assetsOf, awaitTransaction, btcTarget, buildForfeitTx, buildOffchainTx, buildPreimageMessage, buildSaltedPreimageMessage, buildVersion, captureSendDeadline, claimWithPreimageIdentity, closeDatabase, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, contractPreimage, contractSigner, createAssetPacket, createDefaultPaymentRouter, createManagedConnection, decodeArkContract, deleteByIndex, deriveDescriptorLeafCompressedPubKey, deriveDescriptorLeafPubKey, deserializeExitPackage, encodeArkContract, exitObserverFor, gateExclusion, gatedContracts, getAllByIndexValues, getArkPsbtFields, hasBoardingTxExpired, identityDescriptor, invoiceTarget, isArkContract, isBtcAddress, isCltvSatisfied, isContractGenericallySpendable, isCsvSpendable, isDeterministicSigner, isHDDeterministicSignCapable, isLightningInvoice, isLnurl, isMessageBusInitializingError, isMessageBusNotInitializedError, isPerArtifactDescriptor, isRetryableProviderError, isValidArkAddress, logExcludedVtxos, makeHandle, matchServerCheckpoints, normalizeToDescriptor, notifyExitObserved, onchainRail, openDatabase, outpointExclusion, outpointReasons, parseHDDescriptor, promisifyRequest, provisionClaimSecret, provisionRefundKey, registerWalletRestoreHook, resolveAssetAmount, resolveSendAmount, sdkVersion, selectCoinsWithAsset, selectionOf, sequenceToTimelock, serializeExitPackage, setArkPsbtField, setupServiceWorker, signAndSubmitOffchainTx, submitViaEmulator, timelockToSequence, toXOnly, tryResolveSendAmount, validateBatchRecipients, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, walletFeeSource };