@arkade-os/sdk 0.5.0-rc.11 → 0.5.0-rc.13

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-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, N as NormalizedExtendedVirtualCoin, 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, 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-DTvUv5lD.js';
-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-DTvUv5lD.js';
-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-C350s3bP.js';
-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-C350s3bP.js';
-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-DASN1cVk.js';
-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-DASN1cVk.js';
-import { D as DefaultVtxo } from './delegate-D3YHDERL.js';
-export { a as DelegateVtxo } from './delegate-D3YHDERL.js';
+import { af as ReadonlyIdentity, a as Identity, aB as DescriptorSigningRequest, aC as Transaction, ax as SignerSession, a2 as DescriptorProvider, aD as IntentFeeConfig, aE as OffchainInput, aF as FeeAmount, aG as OnchainInput, aH as FeeOutput, X as IntentRepository, Y as ArkIntent, Z as IntentPageFilter, P as PageRequest, D as PageResult, O as Outpoint, _ as VirtualTxRepository, $ as VirtualTx, a0 as VtxoBranch, W as WalletRepository, B as ExtendedVirtualCoin, F as ScriptVtxoCursor, H as ScriptVtxoPageOptions, J as StoredVtxo, K as VtxoRepositoryKey, E as ExtendedCoin, L as TransactionHistoryPageFilter, M as TransactionHistoryPageCursor, h as ArkTransaction, Q as WalletState, z as Contract, C as ContractRepository, U as ContractFilter, I as IWallet, u as ArkProvider, av as SettlementConfig, aI as ContractWatcherConfig, aJ as Asset, R as Recipient, aK as FeeInfo, o as SettlementEvent, N as NormalizedExtendedVirtualCoin, S as SettleParams, G as GetArkadeInfoOptions, aL as GetVtxosOptions, aM as PaginationOptions, f as GetVtxosFilter, g as GetSpendableVtxosFilter, aN as CreateContractParams, aO as GetContractsFilter, y as VirtualCoin, aP as GetSpendablePathsOptions, aQ as GetAllSpendingPathsOptions, l as GetNewAddressesOptions, aR as IssuanceParams, aS as ReissuanceParams, aT as BurnParams, aU as RenewVtxosOptions, A as ArkadeInfo, aV as NormalizedVtxoPage, c as ArkadeReader, d as ArkadeBroadcaster, e as WalletBalance, am as ContractSyncState, aq as ContractWithVtxos, aW as WatchedScript, aX as PathSelection, m as NewAddress, aY as ContractEvent, aZ as AssetDetails, a_ as IssuanceResult, a$ as DelegateInfo, b0 as MigrationGlobalSkipReason, b1 as MigrationLegSkipReason, b2 as SignerStatus, ae as IReadonlyWallet, i as ActivityRegistry, al as IReadonlyAssetManager, b3 as StorageConfig, j as Activity, k as IContractManager, q as IAssetManager, p as SendParams, n as IDelegateManager, b4 as IVtxoManager, ag as OnchainProvider, a3 as Network, ao as NetworkName, as as Coin, b5 as SendBitcoinParams, b6 as ExplorerTransaction, ay as SignedIntent, az as Intent, b7 as TreeNonces, b8 as TreePartialSigs, T as TxNotificationEvent, b9 as PendingTx, x as TapLeafScript, ba as EncodedVtxoScript, a4 as CSVMultisigTapscript, w as RelativeTimelock, V as VtxoScript, bb as Status, ap as ArkAddress, bc as ChainTx, v as IndexerProvider, a7 as TxTree, bd as PathContext } from './index-CKmB14Yu.js';
+export { be as ActivityIntent, bf as ActivityResolver, bg as ArkIntentState, bh as ArkTapscript, bi as AssetMetadata, bj as BITCOIN_EMULATOR_PUBKEY, bk as BaseWalletConfig, ab as BatchFailedEvent, a9 as BatchFinalizationEvent, aa as BatchFinalizedEvent, bl as BatchInfo, bm as BatchSignableIdentity, a5 as BatchStartedEvent, bn as CLTVMultisigTapscript, bo as CandidateDeps, bp as ChainTxType, a1 as ChainedTxType, bq as CommitmentTx, br as ConditionCSVMultisigTapscript, bs as ConditionMultisigTapscript, bt as ContractBalance, bu as ContractEventCallback, bv as ContractHandler, at as ContractManager, au as ContractManagerConfig, bw as ContractState, bx as ContractVtxo, by as ContractVtxoEvent, bz as ContractWatcher, bA as DEFAULT_VTXO_PAGE_SIZE, bB as DelegateManagerImpl, bC as DelegateOptions, ah as DelegateProvider, bD as DeprecatedSignerMigrationReport, bE as DeprecatedSignerReport, bF as DigestMismatchError, bG as Discoverable, bH as DiscoveredContract, bI as DiscoveryDeps, bJ as ESPLORA_URL, bK as EsploraProvider, bL as EventSourceCapable, bM as EventSourceFactory, bN as EventSourceLike, bO as EventSourceUnavailableError, aj as ExitCaptureMode, bP as ExitChainResolver, ak as ExitDataSource, bQ as ExtendedContractVtxo, bR as GroupMembership, bS as HandlerError, bT as INTENT_TERMINAL_STATES, bU as IndexerTxType, bV as IntentCoin, bW as IntentFilter, bX as KnownMetadata, bY as MAX_PAGE_SIZE, bZ as MUTINYNET_EMULATOR_PUBKEY, b_ as MigrateDeprecatedSignerOptions, b$ as MigrationLegReport, c0 as MigrationVtxoRef, c1 as MultisigTapscript, c2 as NewAddressType, c3 as Nonces, c4 as Output, c5 as PageResponse, c6 as PartialSig, c7 as PrevTxSource, c8 as PrevTxUnavailableError, c9 as ProviderClass, ca as REGTEST_EMULATOR_PUBKEY, cb as RawTxSource, ai as ReadonlyWalletConfig, an as RecipientArkadeAddressContext, r as RestArkProvider, cc as RestDelegateProvider, s as RestIndexerProvider, cd as ScanContractsOptions, ce as ScanResult, cf as ScheduledSession, cg as SettlementEventType, ch as SignRequest, ci as SignerClassification, cj as SignerSet, ck as SubscriptionEvent, cl as SubscriptionHeartbeat, t as SubscriptionResponse, cm as SweepTxNotification, cn as TapLeaves, co as TapTreeCoder, cp as TapscriptType, aA as TimeHeight, a8 as TreeNoncesEvent, ad as TreeSignatureEvent, a6 as TreeSigningStartedEvent, ac as TreeTxEvent, cq as Tx, cr as TxHistoryRecord, cs as TxKey, ct as TxNotification, cu as TxTag, cv as TxTreeNode, cw as TxType, cx as Vtxo, cy as VtxoChain, aw as VtxoManager, cz as VtxoType, b as WalletConfig, cA as WalletMode, cB as WithPrevTx, cC as assertAllowedSighashTypes, cD as assertPageRequest, cE as assertRecipientArkadeAddress, cF as assetMintResolver, cG as attachPrevArkTxs, cH as attachPrevoutTxs, cI as boardingResolver, cJ as canRecoverOnchain, cK as canSpendOffchain, cL as canSweepOnchain, cM as classifyAgainstSignerSet, cN as classifyContractSigner, cO as collabExitResolver, cP as collectContracts, cQ as collectIntents, cR as collectPages, cS as collectScriptVtxos, cT as collectTransactionHistory, cU as collectUtxos, cV as collectVtxos, cW as configureEventSource, cX as createDefaultActivityRegistry, cY as createExitChainResolver, cZ as decodeTapscript, c_ as defaultEmulatorPubkey, c$ as getAllNormalizedVtxos, d0 as getConfiguredEventSource, d1 as getNetwork, d2 as getNormalizedVtxos, d3 as getRandomId, d4 as getSequence, d5 as hasCandidates, d6 as isBatchSignable, d7 as isContractVtxoEvent, d8 as isCooperativelyMigratable, d9 as isDiscoverable, da as isEventSourceUnavailableError, db as isPastExpiry, dc as isSigningIdentity, dd as isSubdust, de as isTerminalIntentState, df as isVirtualCoin, dg as isVtxoExpiringSoon, dh as isVtxoSpent, di as iteratePages, dj as networkFromArkadeInfo, dk as networks, dl as pageResult, dm as resolveEmulatorPubkey, dn as resolveEventSource, dp as resolvePrevTxs, dq as scriptFromTapLeafScript, dr as signerSetFromInfo, ds as toXOnlySignerHex, dt as withPrevTxs } from './index-CKmB14Yu.js';
+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-DXNiCmq8.js';
+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 './wallet-DXNiCmq8.js';
+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, l as TweakedSigner, 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-DbzyrqK7.js';
+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-DbzyrqK7.js';
+import { D as DefaultVtxo } from './delegate-BuagcGnG.js';
+export { a as DelegateVtxo } from './delegate-BuagcGnG.js';
 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';
@@ -109,9 +109,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 +122,18 @@ type MnemonicOptions = SeedIdentityOptions & {
     passphrase?: string;
 };
 /**
- * Seed-based identity derived from a raw seed and an account descriptor
- * *template*.
+ * 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.
+ * 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.
  *
- * Prefer this (or @see MnemonicIdentity) over `SingleKey` for new
- * integrations — `SingleKey` exists for backward compatibility with
- * raw nsec-style keys.
+ * {@link descriptor} holds the wildcard template (e.g. `tr([fp/86'/0'/0']xpub/0/*)`); consumers
+ * materialize concrete indices themselves (see `HDDescriptorProvider`).
  *
- * 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).
- *
- * 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 +151,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 +173,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 +201,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 +215,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 +237,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>;
@@ -553,7 +489,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>;
 }
@@ -608,7 +544,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 +554,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[]>;
+    getUtxosPage(address: string, page: PageRequest<Outpoint>): Promise<PageResult<ExtendedCoin, Outpoint>>;
     saveUtxos(address: string, 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 +578,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 +598,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 +651,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 +673,9 @@ interface ParsedArkContract {
  */
 declare function decodeArkContract(encoded: string): ParsedArkContract;
 /**
- * Create a Contract from an arkcontract string.
- *
- * This requires a handler to be registered for the contract type.
+ * Create a Contract (without script/address) from an arkcontract string.
  *
- * @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 +698,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,11 +729,11 @@ 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>;
     private applyContractFilter;
@@ -880,21 +745,22 @@ declare class IndexedDBContractRepository implements ContractRepository {
  * IndexedDB-based implementation of WalletRepository.
  */
 declare class IndexedDBWalletRepository implements WalletRepository {
-    readonly version: 1;
+    readonly version: 2;
     private readonly connection;
     constructor(dbName?: string);
     clear(): Promise<void>;
     [Symbol.asyncDispose](): Promise<void>;
-    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[]>;
+    getUtxosPage(address: string, page: PageRequest<Outpoint>): Promise<PageResult<ExtendedCoin, Outpoint>>;
+    private pageByAddress;
     saveUtxos(address: string, 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>;
@@ -909,43 +775,28 @@ interface WalletRestoreHook {
 declare function registerWalletRestoreHook(wallet: IWallet, hook: WalletRestoreHook): () => void;
 
 /**
- * Domain separator for the preimage derivation.
- *
- * 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.
+ * 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 +815,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 +837,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 +899,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 +915,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 +977,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 +998,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;
@@ -1226,11 +1050,7 @@ type Options = {
      */
     intentRepository?: IntentRepository;
     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";
@@ -1387,51 +1207,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).
+ * Assemble a Taproot script tree with btcd's `txscript.AssembleTaprootScriptTree` algorithm
+ * (the one arkd uses).
  *
- * The algorithm:
+ * `@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`.
  *
- *   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])
- *
- *   Phase 2 — FIFO-queue merge branches:
- *     while branches has ≥ 2 items:
- *       take front two, combine into a new branch, push to back of queue
- *
- * 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 +1283,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 +1294,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 +1301,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 +1323,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 +1360,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 +1379,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 +1746,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 +1798,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
@@ -2209,28 +1955,20 @@ declare class Ramps {
         eventCallback?: (event: SettlementEvent) => void;
         vtxos?: NormalizedExtendedVirtualCoin[];
     }): ReturnType<IWallet["settle"]>;
+    private offboardInputs;
     /** 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.
- *
- * 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.
+ * 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.
  *
- * 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
@@ -2246,104 +1984,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;
 }
@@ -2471,13 +2155,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 & {
@@ -2575,12 +2260,18 @@ 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 RequestWatchScript = RequestEnvelope & {
@@ -3274,13 +2965,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;
@@ -3295,6 +2979,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.
@@ -3319,20 +3005,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;
     /**
@@ -3388,7 +3062,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.
      *
@@ -3407,7 +3081,6 @@ declare class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet implements
     private _restoreInFlight?;
     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
@@ -5056,11 +4729,6 @@ 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;
 
@@ -5209,7 +4877,8 @@ declare class Extension {
  * This module defines ONLY Arkade-specific opcodes (0xb3, 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: {
@@ -5596,45 +5265,70 @@ 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;
+    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 {
+    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. The shape
+ * mirrors the compiler artifact, so hand-written programs and compiler output share one resolver.
+ * 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); bare name strings are documentation only.
+ *
+ * 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
@@ -5677,10 +5371,8 @@ type FnArgs<F extends ArkadeFunction> = F extends {
     inputs: infer I extends readonly InputRef[];
 } ? 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;
@@ -5691,13 +5383,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;
 }
@@ -5733,33 +5421,19 @@ 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 {
     /**
-     * The Arkade server provider.
-     *
-     * 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.
+     * 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;
     /**
@@ -5776,31 +5450,24 @@ interface ArkadeConnectOptions {
      */
     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.
+     * 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.
      *
      * @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()`.
+     * The wallet's contract manager (`wallet.getContractManager()`). Enables
+     * {@link ArkadeContract.register}, and makes {@link ArkadeContract.getUtxos} read
+     * repository-backed state for registered contracts instead of the indexer.
      */
     contractManager?: IContractManager;
 }
 /**
- * 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;
@@ -5809,14 +5476,10 @@ declare class Arkade {
     readonly network: Network;
     readonly serverKey: Uint8Array;
     /**
-     * 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;
@@ -5830,14 +5493,11 @@ declare class Arkade {
     /** Connect and resolve the server key, checkpoint closure and (if present) the co-signer key. */
     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.
+     * 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.
+     * Unbound declared `server`/`user` params default to the client's server key / identity key;
+     * explicit args win.
      */
     contract<const P extends Program>(program: P, args?: Record<string, ArkadeParamValue>): ArkadeContract<P>;
 }
@@ -5856,11 +5516,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. */
@@ -5869,16 +5526,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;
@@ -5887,26 +5539,17 @@ 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.
-     *
-     * 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.
-     *
-     * 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.
+     * 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). */
@@ -6003,6 +5646,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;
@@ -6016,6 +5660,7 @@ 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;
 type index_Utxo = Utxo;
 declare const index_WitnessRef: typeof WitnessRef;
 declare const index_arkadeScriptHash: typeof arkadeScriptHash;
@@ -6028,7 +5673,9 @@ 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_resolveAsm: typeof resolveAsm;
 declare const index_serializeArkadeContractParams: typeof serializeArkadeContractParams;
 declare const index_stringifyArtifact: typeof stringifyArtifact;
@@ -6036,7 +5683,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, 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_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_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, 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_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. */
@@ -6114,24 +5761,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:
- *
- * - `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.
+ * 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`.
  *
- * 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 omits the per-input intent fees whenever the request left
- * the VTXO selection to settlement — naming {@link PaymentRequest.selectedVtxos}
- * fixes them, and they are priced in. 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;
@@ -6142,31 +5779,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;
@@ -6205,14 +5829,10 @@ interface PaymentRequest {
      *  legitimately has both. A rail that cannot deliver assets must REFUSE. */
     assets?: Asset[];
     /**
-     * Spend exactly these virtual outputs, with the meaning
-     * {@link SendParams.selectedVtxos} already gives it: taken as given, so a
-     * shortfall is an error rather than a top-up, and ungated like
-     * `settle({ inputs })`. Normalized, i.e. what `getSpendableVtxos()` returns.
-     *
-     * Only the rails spending the wallet's own coins can honour it (`ark`,
-     * `ark-asset`, `onchain`). A rail funding its payment through a counterparty
-     * picks its own inputs, so it must REFUSE rather than ignore the selection.
+     * 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[];
 }
@@ -6449,9 +6069,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,
@@ -6470,12 +6088,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;
 
@@ -6538,46 +6153,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
-     *
-     * `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.
+     * 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.
      *
-     * 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;
 
@@ -6687,4 +6278,4 @@ declare class AssetManager extends ReadonlyAssetManager implements IAssetManager
     burn(params: BurnParams): Promise<string>;
 }
 
-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, NormalizedExtendedVirtualCoin, NormalizedVtxoPage, OffchainInput, type OffchainTx, type OnExitObserved, OnchainInput, OnchainProvider, OnchainWallet, Outpoint, OversizedChangeError, 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, assertNoSelection, 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, selectionOf, 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, 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, ContractFilter, 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, GetSpendableVtxosFilter, 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, 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, RestEmulatorProvider, type RouteQuote, type RouteResult, type RouterContext, type RouterPreferences, ScriptVtxoCursor, ScriptVtxoPageOptions, SeedIdentity, type SeedIdentityOptions, SendBitcoinParams, SendParams, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, type ServiceWorkerWalletMode, SettleParams, SettlementConfig, SettlementEvent, SignedIntent, SignerSession, SignerStatus, SingleKey, Status, StorageConfig, StoredVtxo, TapLeafScript, Transaction, TransactionHistoryPageCursor, TransactionHistoryPageFilter, 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, assertNoSelection, 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, selectionOf, sequenceToTimelock, serializeExitPackage, setArkPsbtField, setupServiceWorker, signAndSubmitOffchainTx, timelockToSequence, toXOnly, tryResolveSendAmount, validateBatchRecipients, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, walletFeeSource };