@arkade-os/sdk 0.4.65 → 0.4.67

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-import { a2 as ReadonlyIdentity, a as Identity, ap as DescriptorSigningRequest, aq as Transaction, al as SignerSession, K as DescriptorProvider, ar as IntentFeeConfig, as as OffchainInput, at as FeeAmount, au as OnchainInput, av as FeeOutput, y as IntentRepository, z as ArkIntent, B as IntentFilter, O as Outpoint, D as VirtualTxRepository, F as VirtualTx, H as VtxoBranch, W as WalletRepository, u as ExtendedVirtualCoin, v as VtxoRepositoryKey, E as ExtendedCoin, A as ArkTransaction, w as WalletState, t as Contract, C as ContractRepository, x as ContractFilter, I as IWallet, o as ArkProvider, aj as SettlementConfig, aw as ContractWatcherConfig, ax as Asset, R as Recipient, ay as FeeInfo, i as SettlementEvent, h as SettleParams, S as SendBitcoinParams, G as GetVtxosFilter, az as CreateContractParams, aA as GetContractsFilter, s as VirtualCoin, aB as GetSpendablePathsOptions, aC as GetAllSpendingPathsOptions, aD as IssuanceParams, aE as ReissuanceParams, aF as BurnParams, aG as RenewVtxosOptions, c as WalletBalance, a9 as ContractSyncState, ae as ContractWithVtxos, aH as PathSelection, aI as ContractEvent, aJ as AssetDetails, aK as IssuanceResult, aL as DelegateInfo, aM as MigrationGlobalSkipReason, aN as MigrationLegSkipReason, aO as SignerStatus, a1 as IReadonlyWallet, d as ActivityRegistry, a8 as IReadonlyAssetManager, aP as StorageConfig, e as Activity, N as NormalizedExtendedVirtualCoin, f as IContractManager, k as IAssetManager, j as SendParams, g as IDelegateManager, aQ as IVtxoManager, a3 as OnchainProvider, L as Network, ab as NetworkName, ag as Coin, aR as ExplorerTransaction, r as TapLeafScript, aS as EncodedVtxoScript, M as CSVMultisigTapscript, q as RelativeTimelock, V as VtxoScript, aT as Status, ad as ArkAddress, an as Intent, aU as ChainTx, p as IndexerProvider, U as TxTree, aV as PathContext } from './index-CFOMyVMt.js';
-export { aW as ActivityIntent, aX as ActivityResolver, ac as ArkInfo, aY as ArkIntentState, aZ as ArkTapscript, a_ as AssetMetadata, a$ as BITCOIN_EMULATOR_PUBKEY, b0 as BaseWalletConfig, _ as BatchFailedEvent, Y as BatchFinalizationEvent, Z as BatchFinalizedEvent, b1 as BatchInfo, b2 as BatchSignableIdentity, P as BatchStartedEvent, b3 as CLTVMultisigTapscript, b4 as CandidateDeps, b5 as ChainTxType, J as ChainedTxType, b6 as CommitmentTx, b7 as ConditionCSVMultisigTapscript, b8 as ConditionMultisigTapscript, b9 as ContractBalance, ba as ContractEventCallback, bb as ContractHandler, ah as ContractManager, ai as ContractManagerConfig, bc as ContractState, bd as ContractVtxo, be as ContractWatcher, bf as DelegateManagerImpl, bg as DelegateOptions, a4 as DelegateProvider, bh as DelegatorManagerImpl, bi as DelegatorProvider, bj as DeprecatedSignerMigrationReport, bk as DeprecatedSignerReport, bl as DigestMismatchError, bm as Discoverable, bn as DiscoveredContract, bo as DiscoveryDeps, bp as ESPLORA_URL, bq as EsploraProvider, br as EventSourceCapable, bs as EventSourceFactory, bt as EventSourceLike, bu as EventSourceUnavailableError, a6 as ExitCaptureMode, bv as ExitChainResolver, a7 as ExitDataSource, bw as ExtendedContractVtxo, bx as GroupMembership, by as HandlerError, bz as IDelegatorManager, bA as INTENT_TERMINAL_STATES, bB as IndexerTxType, bC as KnownMetadata, bD as MUTINYNET_EMULATOR_PUBKEY, bE as MigrateDeprecatedSignerOptions, bF as MigrationLegReport, bG as MigrationVtxoRef, bH as MultisigTapscript, bI as Nonces, bJ as Output, bK as PageResponse, bL as PaginationOptions, bM as PartialSig, bN as ProviderClass, bO as REGTEST_EMULATOR_PUBKEY, a5 as ReadonlyWalletConfig, l as RestArkProvider, bP as RestDelegateProvider, bQ as RestDelegatorProvider, m as RestIndexerProvider, bR as ScanContractsOptions, bS as ScanResult, bT as ScheduledSession, bU as SettlementEventType, bV as SignRequest, am as SignedIntent, bW as SignerClassification, bX as SignerSet, bY as SubscriptionEvent, bZ as SubscriptionHeartbeat, n as SubscriptionResponse, b_ as TapLeaves, b$ as TapTreeCoder, c0 as TapscriptType, ao as TimeHeight, c1 as TreeNonces, X as TreeNoncesEvent, c2 as TreePartialSigs, a0 as TreeSignatureEvent, Q as TreeSigningStartedEvent, $ as TreeTxEvent, c3 as Tx, c4 as TxHistoryRecord, c5 as TxKey, T as TxNotification, c6 as TxTag, c7 as TxTreeNode, c8 as TxType, c9 as VirtualStatus, ca as Vtxo, cb as VtxoChain, ak as VtxoManager, cc as VtxoType, b as WalletConfig, cd as WalletMode, ce as assetMintResolver, cf as boardingResolver, cg as canRecoverOnchain, ch as canSpendOffchain, ci as classifyAgainstSignerSet, cj as classifyContractSigner, ck as collabExitResolver, cl as configureEventSource, cm as createDefaultActivityRegistry, cn as createExitChainResolver, co as decodeTapscript, cp as defaultEmulatorPubkey, cq as getConfiguredEventSource, cr as getNetwork, cs as getRandomId, ct as getSequence, cu as hasCandidates, cv as hasTerminalSpend, cw as isBatchSignable, cx as isCooperativelyMigratable, cy as isDiscoverable, cz as isEventSourceUnavailableError, cA as isExpired, cB as isPastExpiry, cC as isRecoverable, cD as isSigningIdentity, cE as isSpendable, cF as isSubdust, cG as isTerminalIntentState, cH as isVirtualCoin, cI as isVtxoExpiringSoon, cJ as networks, cK as resolveEmulatorPubkey, cL as resolveEventSource, cM as scriptFromTapLeafScript, cN as signerSetFromInfo, cO as toXOnlySignerHex } from './index-CFOMyVMt.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, B as BatchExpiryPolicy, e as Batch } from './wallet-DJUnN939.js';
-export { A as ArkError, f as ArkErrorName, g as ArkadeCashClaimResult, h as ArkadeCashCreateError, i as ArkadeCashUnclaimedReason, j as ArkadeCashUnclaimedVtxo, k as BoardingUtxoGroup, C as CheckpointExitDelayPolicy, D as DEFAULT_MIN_BATCH_EXPIRY_SECONDS, l as DEFAULT_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, F as ForeignDescriptorError, I as IncomingFunds, M as MAX_USED_SIGNING_DESCRIPTORS_LOOK_AHEAD, m as MUTINYNET_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, n as ProviderKind, o as ProviderUnavailableError, p as REGTEST_MIN_BATCH_EXPIRY_SECONDS, q as REGTEST_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, S as SIGNET_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, r as ServerInfoSource, s as ServerResponseMismatchError, t as assertValidBatchExpiry, u as assertValidServerUnrollScript, v as defaultBatchExpiryPolicy, w as defaultCheckpointExitDelayPolicy, x as isArkError, y as isHDAllocationCapable, z as isHDWalletCapable, E as maybeArkError, G as resolveBatchExpiryPolicy, J as resolveCheckpointExitDelayPolicy, K as resolveDescriptorSigner, L as selectVirtualCoins, N as signingDescriptorIndex, O as strictSigningDescriptorIndex, Q as waitForIncomingFunds } from './wallet-DJUnN939.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-fDDiA1-L.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-fDDiA1-L.js';
-import { D as DefaultVtxo } from './delegate-Dv_9OVHv.js';
-export { a as DelegateVtxo } from './delegate-Dv_9OVHv.js';
+import { a4 as ReadonlyIdentity, a as Identity, ar as DescriptorSigningRequest, as as Transaction, an as SignerSession, a2 as DescriptorProvider, at as IntentFeeConfig, au as OffchainInput, av as FeeAmount, aw as OnchainInput, ax as FeeOutput, B as IntentRepository, D as ArkIntent, F as IntentFilter, O as Outpoint, H as VirtualTxRepository, J as VirtualTx, K as VtxoBranch, W as WalletRepository, w as ExtendedVirtualCoin, x as VtxoRepositoryKey, E as ExtendedCoin, A as ArkTransaction, y as WalletState, v as Contract, C as ContractRepository, z as ContractFilter, I as IWallet, q as ArkProvider, al as SettlementConfig, ay as ContractWatcherConfig, az as Asset, R as Recipient, aA as FeeInfo, k as SettlementEvent, j as SettleParams, S as SendBitcoinParams, G as GetVtxosFilter, aB as CreateContractParams, aC as GetContractsFilter, u as VirtualCoin, aD as GetSpendablePathsOptions, aE as GetAllSpendingPathsOptions, g as GetNewAddressesOptions, aF as IssuanceParams, aG as ReissuanceParams, aH as BurnParams, aI as RenewVtxosOptions, c as WalletBalance, ab as ContractSyncState, ag as ContractWithVtxos, aJ as PathSelection, h as NewAddress, aK as ContractEvent, aL as AssetDetails, aM as IssuanceResult, aN as DelegateInfo, aO as MigrationGlobalSkipReason, aP as MigrationLegSkipReason, aQ as SignerStatus, a3 as IReadonlyWallet, d as ActivityRegistry, aa as IReadonlyAssetManager, aR as StorageConfig, e as Activity, N as NormalizedExtendedVirtualCoin, f as IContractManager, m as IAssetManager, l as SendParams, i as IDelegateManager, aS as IVtxoManager, a5 as OnchainProvider, M as Network, ad as NetworkName, ai as Coin, aT as ExplorerTransaction, ae as ArkInfo, ao as SignedIntent, ap as Intent, aU as TreeNonces, aV as TreePartialSigs, T as TxNotificationEvent, aW as PendingTx, t as TapLeafScript, aX as EncodedVtxoScript, P as CSVMultisigTapscript, s as RelativeTimelock, V as VtxoScript, aY as Status, af as ArkAddress, aZ as ChainTx, r as IndexerProvider, X as TxTree, a_ as PathContext } from './index-DU5o_hz7.js';
+export { a$ as ActivityIntent, b0 as ActivityResolver, b1 as ArkIntentState, b2 as ArkTapscript, b3 as AssetMetadata, b4 as BITCOIN_EMULATOR_PUBKEY, b5 as BaseWalletConfig, $ as BatchFailedEvent, Z as BatchFinalizationEvent, _ as BatchFinalizedEvent, b6 as BatchInfo, b7 as BatchSignableIdentity, Q as BatchStartedEvent, b8 as CLTVMultisigTapscript, b9 as CandidateDeps, ba as ChainTxType, L as ChainedTxType, bb as CommitmentTx, bc as ConditionCSVMultisigTapscript, bd as ConditionMultisigTapscript, be as ContractBalance, bf as ContractEventCallback, bg as ContractHandler, aj as ContractManager, ak as ContractManagerConfig, bh as ContractState, bi as ContractVtxo, bj as ContractWatcher, bk as DEFAULT_VTXO_PAGE_SIZE, bl as DelegateManagerImpl, bm as DelegateOptions, a6 as DelegateProvider, bn as DelegatorManagerImpl, bo as DelegatorProvider, bp as DeprecatedSignerMigrationReport, bq as DeprecatedSignerReport, br as DigestMismatchError, bs as Discoverable, bt as DiscoveredContract, bu as DiscoveryDeps, bv as ESPLORA_URL, bw as EsploraProvider, bx as EventSourceCapable, by as EventSourceFactory, bz as EventSourceLike, bA as EventSourceUnavailableError, a8 as ExitCaptureMode, bB as ExitChainResolver, a9 as ExitDataSource, bC as ExtendedContractVtxo, bD as GroupMembership, bE as HandlerError, bF as IDelegatorManager, bG as INTENT_TERMINAL_STATES, bH as IndexerTxType, bI as IntentCoin, bJ as KnownMetadata, bK as MUTINYNET_EMULATOR_PUBKEY, bL as MigrateDeprecatedSignerOptions, bM as MigrationLegReport, bN as MigrationVtxoRef, bO as MultisigTapscript, bP as NewAddressType, bQ as Nonces, bR as Output, bS as PageResponse, bT as PaginationOptions, bU as PartialSig, bV as PrevTxSource, bW as PrevTxUnavailableError, bX as ProviderClass, bY as REGTEST_EMULATOR_PUBKEY, bZ as RawTxSource, a7 as ReadonlyWalletConfig, n as RestArkProvider, b_ as RestDelegateProvider, b$ as RestDelegatorProvider, o as RestIndexerProvider, c0 as ScanContractsOptions, c1 as ScanResult, c2 as ScheduledSession, c3 as SettlementEventType, c4 as SignRequest, c5 as SignerClassification, c6 as SignerSet, c7 as SubscriptionEvent, c8 as SubscriptionHeartbeat, p as SubscriptionResponse, c9 as SweepTxNotification, ca as TapLeaves, cb as TapTreeCoder, cc as TapscriptType, aq as TimeHeight, Y as TreeNoncesEvent, a1 as TreeSignatureEvent, U as TreeSigningStartedEvent, a0 as TreeTxEvent, cd as Tx, ce as TxHistoryRecord, cf as TxKey, cg as TxNotification, ch as TxTag, ci as TxTreeNode, cj as TxType, ck as VirtualStatus, cl as Vtxo, cm as VtxoChain, am as VtxoManager, cn as VtxoType, b as WalletConfig, co as WalletMode, cp as WithPrevTx, cq as assetMintResolver, cr as attachPrevArkTxs, cs as attachPrevoutTxs, ct as boardingResolver, cu as canRecoverOnchain, cv as canSpendOffchain, cw as canSweepOnchain, cx as classifyAgainstSignerSet, cy as classifyContractSigner, cz as collabExitResolver, cA as configureEventSource, cB as createDefaultActivityRegistry, cC as createExitChainResolver, cD as decodeTapscript, cE as defaultEmulatorPubkey, cF as getConfiguredEventSource, cG as getNetwork, cH as getRandomId, cI as getSequence, cJ as hasCandidates, cK as hasTerminalSpend, cL as isBatchSignable, cM as isCooperativelyMigratable, cN as isDiscoverable, cO as isEventSourceUnavailableError, cP as isExpired, cQ as isPastExpiry, cR as isRecoverable, cS as isSigningIdentity, cT as isSpendable, cU as isSubdust, cV as isTerminalIntentState, cW as isVirtualCoin, cX as isVtxoExpiringSoon, cY as networks, cZ as resolveEmulatorPubkey, c_ as resolveEventSource, c$ as resolvePrevTxs, d0 as scriptFromTapLeafScript, d1 as signerSetFromInfo, d2 as toXOnlySignerHex, d3 as withPrevTxs } from './index-DU5o_hz7.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-Hi12xjCJ.js';
+export { f as ArkError, g as ArkErrorName, h as ArkadeCashClaimResult, i as ArkadeCashCreateError, j as ArkadeCashUnclaimedReason, k as ArkadeCashUnclaimedVtxo, l as BoardingUtxoGroup, C as CheckpointExitDelayPolicy, D as DEFAULT_MIN_BATCH_EXPIRY_SECONDS, m as DEFAULT_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, F as ForeignDescriptorError, I as IncomingFunds, M as MAX_USED_SIGNING_DESCRIPTORS_LOOK_AHEAD, n as MUTINYNET_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, o as ProviderKind, p as ProviderUnavailableError, q as REGTEST_MIN_BATCH_EXPIRY_SECONDS, r as REGTEST_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, S as SIGNET_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, s as ServerInfoSource, t as ServerResponseMismatchError, u as WalletCannotAllocateAddressError, v as assertValidBatchExpiry, w as assertValidServerUnrollScript, x as defaultBatchExpiryPolicy, y as defaultCheckpointExitDelayPolicy, z as isAddressAllocationCapable, E as isArkError, G as isHDAllocationCapable, J as isHDWalletCapable, K as maybeArkError, L as resolveBatchExpiryPolicy, N as resolveCheckpointExitDelayPolicy, O as resolveDescriptorSigner, Q as selectVirtualCoins, T as signingDescriptorIndex, U as strictSigningDescriptorIndex, V as waitForIncomingFunds } from './hdWalletCapable-Hi12xjCJ.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-BiACuWaf.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-BiACuWaf.js';
+import { D as DefaultVtxo } from './delegate-cdmzb2f9.js';
+export { a as DelegateVtxo } from './delegate-cdmzb2f9.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';
@@ -1076,9 +1076,29 @@ interface ProvisionedKey {
      * artifact; {@link contractSigner} resolves it back to a signer.
      */
     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.
+     */
+    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
+     * `getAddress()` call.
+     */
+    address: string;
 }
-/** A claim key together with the preimage it claims with. */
-interface ProvisionedClaimSecret extends ProvisionedKey {
+/**
+ * A claim key together with the preimage it claims with. `pkScript` and
+ * `address` are excluded: a claim leg funds nothing, so it names no refund
+ * destination.
+ */
+interface ProvisionedClaimSecret extends Omit<ProvisionedKey, "pkScript" | "address"> {
     preimage: Uint8Array;
     /** `sha256(preimage)` — what the contract commits to. */
     paymentHash: Uint8Array;
@@ -1114,9 +1134,10 @@ interface ProvisionedClaimSecret extends ProvisionedKey {
  * the failure would surface at refund time with the money already committed.
  * Throws {@link ForeignDescriptorError} instead, before there is a quote.
  *
- * On an HD wallet this consumes an index even if the artifact is never built,
- * and a swap index never becomes a funded receive contract, so a long run of
- * them widens the gap a seed-only restore scan sees.
+ * 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.
  */
 declare function provisionRefundKey(wallet: IWallet): Promise<ProvisionedKey>;
 /**
@@ -1246,6 +1267,11 @@ interface MessageHandler<REQ extends RequestEnvelope = RequestEnvelope, RES exte
      * Called once when the SW is starting up
      * @param services - Providers and wallet instances available to the handler.
      * @param repositories - Repositories available to the handler.
+     * @param channel - Push channel to clients, for responses that answer no
+     * request. Use it instead of holding events for the next {@link tick}.
+     * The channel is scoped to the generation it was handed out in: after a
+     * bus re-init or `stop()` it goes inert on its own, so retaining one past
+     * `stop()` cannot post.
      **/
     start(services: {
         arkProvider: ArkProvider;
@@ -1253,6 +1279,8 @@ interface MessageHandler<REQ extends RequestEnvelope = RequestEnvelope, RES exte
         readonlyWallet: ReadonlyWallet;
     }, repositories: {
         walletRepository: WalletRepository;
+    }, channel?: {
+        broadcast(response: RES): void;
     }): Promise<void>;
     /** Called once when the SW is shutting down */
     stop(): Promise<void>;
@@ -1365,12 +1393,31 @@ declare class MessageBus {
     private readonly buildServicesFn;
     private readonly boundOnMessage;
     private readonly intentRepository?;
+    /** Pending broadcasts, drained FIFO by a single {@link drain} loop. */
+    private broadcastQueue;
+    private draining;
+    /** Bumped wherever the generation owning the queued broadcasts ends. */
+    private broadcastEpoch;
     /** Create the service-worker message bus with repositories and handler configuration. */
     constructor(walletRepository: WalletRepository, contractRepository: ContractRepository, { messageHandlers, tickIntervalMs, messageTimeoutMs, messageTimeoutOverrides, intentRepository, debug, buildServices, }: Options);
     /** Start the message bus and attach service-worker event listeners. */
     start(): Promise<void>;
     /** Stop the message bus, cancel ticks, and stop all registered handlers. */
     stop(): Promise<void>;
+    /** Invalidate every broadcast belonging to the outgoing generation. */
+    private invalidateBroadcasts;
+    private broadcastToClients;
+    /**
+     * Single fan-out loop, so pushes and tick responses keep one FIFO order.
+     * A helper posting per response would race: `clients.matchAll()` gives no
+     * cross-call resolution order, and it would de-batch `runTick`.
+     */
+    private drain;
+    /**
+     * A dropped batch has no periodic recovery to fall back on now that events
+     * no longer ride the tick, so name the loss under {@link Options.debug}.
+     */
+    private logDroppedBroadcasts;
     private scheduleNextTick;
     private runTick;
     /**
@@ -2688,6 +2735,16 @@ type ResponseGetNextSigningDescriptor = ResponseEnvelope & {
         descriptor?: string;
     };
 };
+type RequestGetNewAddresses = RequestEnvelope & {
+    type: "GET_NEW_ADDRESSES";
+    payload?: GetNewAddressesOptions;
+};
+type ResponseGetNewAddresses = ResponseEnvelope & {
+    type: "NEW_ADDRESSES";
+    payload: {
+        addresses: NewAddress[];
+    };
+};
 type RequestGetUsedSigningDescriptors = RequestEnvelope & {
     type: "GET_USED_SIGNING_DESCRIPTORS";
     payload?: {
@@ -2985,8 +3042,8 @@ type RequestRestoreWallet = RequestEnvelope & {
 type ResponseRestoreWallet = ResponseEnvelope & {
     type: "RESTORE_WALLET_SUCCESS";
 };
-type WalletUpdaterRequest = RequestInitWallet | RequestSettle | RequestSendBitcoin | RequestGetAddress | RequestGetBoardingAddress | RequestGetBalance | RequestGetVtxos | RequestGetSpendableVtxos | RequestGetBoardingUtxos | RequestGetTransactionHistory | RequestGetStatus | RequestGetContractSyncState | RequestClear | RequestReloadWallet | RequestSignTransaction | RequestCreateContract | RequestGetContracts | RequestGetContractsWithVtxos | RequestAnnotateVtxos | RequestUpdateContract | RequestDeleteContract | RequestGetSpendablePaths | RequestGetAllSpendingPaths | RequestIsContractManagerWatching | RequestRefreshVtxos | RequestRefreshOutpoints | RequestGetCurrentSigningDescriptor | RequestGetNextSigningDescriptor | RequestGetUsedSigningDescriptors | RequestAdvanceSigningDescriptorWatermark | RequestSend | RequestGetAssetDetails | RequestIssue | RequestReissue | RequestBurn | RequestDelegate | RequestGetDelegateInfo | RequestRecoverVtxos | RequestGetRecoverableBalance | RequestGetExpiringVtxos | RequestRenewVtxos | RequestGetExpiredBoardingUtxos | RequestSweepExpiredBoardingUtxos | RequestMigrateDeprecatedSignerVtxos | RequestGetDeprecatedSignerStatus | RequestRestoreWallet;
-type WalletUpdaterResponse = ResponseEnvelope & (ResponseInitWallet | ResponseSettle | ResponseSettleEvent | ResponseSendBitcoin | ResponseGetAddress | ResponseGetBoardingAddress | ResponseGetBalance | ResponseGetVtxos | ResponseGetSpendableVtxos | ResponseGetBoardingUtxos | ResponseGetTransactionHistory | ResponseGetStatus | ResponseGetContractSyncState | ResponseClear | ResponseReloadWallet | ResponseUtxoUpdate | ResponseVtxoUpdate | ResponseSignTransaction | ResponseCreateContract | ResponseGetContracts | ResponseGetContractsWithVtxos | ResponseAnnotateVtxos | ResponseUpdateContract | ResponseDeleteContract | ResponseGetSpendablePaths | ResponseGetAllSpendingPaths | ResponseIsContractManagerWatching | ResponseRefreshVtxos | ResponseRefreshOutpoints | ResponseGetCurrentSigningDescriptor | ResponseGetNextSigningDescriptor | ResponseGetUsedSigningDescriptors | ResponseAdvanceSigningDescriptorWatermark | ResponseContractEvent | ResponseSend | ResponseGetAssetDetails | ResponseIssue | ResponseReissue | ResponseBurn | ResponseDelegate | ResponseGetDelegateInfo | ResponseRecoverVtxos | ResponseRecoverVtxosEvent | ResponseGetRecoverableBalance | ResponseGetExpiringVtxos | ResponseRenewVtxos | ResponseRenewVtxosEvent | ResponseGetExpiredBoardingUtxos | ResponseSweepExpiredBoardingUtxos | ResponseMigrateDeprecatedSignerVtxos | ResponseMigrateDeprecatedSignerVtxosEvent | ResponseGetDeprecatedSignerStatus | ResponseRestoreWallet);
+type WalletUpdaterRequest = RequestInitWallet | RequestSettle | RequestSendBitcoin | RequestGetAddress | RequestGetBoardingAddress | RequestGetBalance | RequestGetVtxos | RequestGetSpendableVtxos | RequestGetBoardingUtxos | RequestGetTransactionHistory | RequestGetStatus | RequestGetContractSyncState | RequestClear | RequestReloadWallet | RequestSignTransaction | RequestCreateContract | RequestGetContracts | RequestGetContractsWithVtxos | RequestAnnotateVtxos | RequestUpdateContract | RequestDeleteContract | RequestGetSpendablePaths | RequestGetAllSpendingPaths | RequestIsContractManagerWatching | RequestRefreshVtxos | RequestRefreshOutpoints | RequestGetCurrentSigningDescriptor | RequestGetNextSigningDescriptor | RequestGetNewAddresses | RequestGetUsedSigningDescriptors | RequestAdvanceSigningDescriptorWatermark | RequestSend | RequestGetAssetDetails | RequestIssue | RequestReissue | RequestBurn | RequestDelegate | RequestGetDelegateInfo | RequestRecoverVtxos | RequestGetRecoverableBalance | RequestGetExpiringVtxos | RequestRenewVtxos | RequestGetExpiredBoardingUtxos | RequestSweepExpiredBoardingUtxos | RequestMigrateDeprecatedSignerVtxos | RequestGetDeprecatedSignerStatus | RequestRestoreWallet;
+type WalletUpdaterResponse = ResponseEnvelope & (ResponseInitWallet | ResponseSettle | ResponseSettleEvent | ResponseSendBitcoin | ResponseGetAddress | ResponseGetBoardingAddress | ResponseGetBalance | ResponseGetVtxos | ResponseGetSpendableVtxos | ResponseGetBoardingUtxos | ResponseGetTransactionHistory | ResponseGetStatus | ResponseGetContractSyncState | ResponseClear | ResponseReloadWallet | ResponseUtxoUpdate | ResponseVtxoUpdate | ResponseSignTransaction | ResponseCreateContract | ResponseGetContracts | ResponseGetContractsWithVtxos | ResponseAnnotateVtxos | ResponseUpdateContract | ResponseDeleteContract | ResponseGetSpendablePaths | ResponseGetAllSpendingPaths | ResponseIsContractManagerWatching | ResponseRefreshVtxos | ResponseRefreshOutpoints | ResponseGetCurrentSigningDescriptor | ResponseGetNextSigningDescriptor | ResponseGetNewAddresses | ResponseGetUsedSigningDescriptors | ResponseAdvanceSigningDescriptorWatermark | ResponseContractEvent | ResponseSend | ResponseGetAssetDetails | ResponseIssue | ResponseReissue | ResponseBurn | ResponseDelegate | ResponseGetDelegateInfo | ResponseRecoverVtxos | ResponseRecoverVtxosEvent | ResponseGetRecoverableBalance | ResponseGetExpiringVtxos | ResponseRenewVtxos | ResponseRenewVtxosEvent | ResponseGetExpiredBoardingUtxos | ResponseSweepExpiredBoardingUtxos | ResponseMigrateDeprecatedSignerVtxos | ResponseMigrateDeprecatedSignerVtxosEvent | ResponseGetDeprecatedSignerStatus | ResponseRestoreWallet);
 declare class WalletMessageHandler implements MessageHandler<WalletUpdaterRequest, WalletUpdaterResponse> {
     readonly messageTag: string;
     private wallet;
@@ -2997,6 +3054,11 @@ declare class WalletMessageHandler implements MessageHandler<WalletUpdaterReques
     private incomingFundsSubscription;
     private contractEventsSubscription;
     private onNextTick;
+    private channel;
+    private incomingFundsEpoch;
+    private contractEventsEpoch;
+    /** Per-request progress callbacks: ends with the handler, not with a re-init. */
+    private requestEpoch;
     /**
      * Instantiate a new WalletUpdater.
      * Can override the default `messageTag` allowing more than one updater to run in parallel.
@@ -3005,10 +3067,17 @@ declare class WalletMessageHandler implements MessageHandler<WalletUpdaterReques
     constructor(options?: {
         messageTag?: string;
     });
-    start(...params: Parameters<MessageHandler["start"]>): Promise<void>;
+    start(...params: Parameters<MessageHandler<WalletUpdaterRequest, WalletUpdaterResponse>["start"]>): Promise<void>;
     stop(): Promise<void>;
     tick(_now: number): Promise<WalletUpdaterResponse[]>;
-    private scheduleForNextTick;
+    private epochOf;
+    private newGeneration;
+    /**
+     * A handle rather than a `broadcast(response, epoch)` call, because it can
+     * only be written where the closure it guards is created — an epoch passed
+     * at the call site reads identically whether it guards anything or not.
+     */
+    private newEmitter;
     private requireWallet;
     private tagged;
     isLongRunning(message: WalletUpdaterRequest): boolean;
@@ -3352,7 +3421,7 @@ declare class ServiceWorkerReadonlyWallet implements IReadonlyWallet {
     reload(): Promise<boolean>;
     getContractManager(): Promise<IContractManager>;
 }
-declare class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet implements IWallet, HDWalletCapable, HDAllocationCapable {
+declare class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet implements IWallet, HDWalletCapable, HDAllocationCapable, AddressAllocationCapable {
     readonly serviceWorker: ServiceWorker;
     readonly walletRepository: WalletRepository;
     readonly contractRepository: ContractRepository;
@@ -3381,6 +3450,22 @@ declare class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet implements
     getCurrentSigningDescriptor(): Promise<string | undefined>;
     /** @see HDAllocationCapable.getNextSigningDescriptor */
     getNextSigningDescriptor(): Promise<string | undefined>;
+    /**
+     * @see Wallet.getNewAddresses
+     *
+     * Proxied as a single request rather than rebuilt page-side out of
+     * {@link getNextSigningDescriptor}: the worker owns the HD watermark *and*
+     * the contract repository, so splitting the operation would let a page burn
+     * an index and then fail to register the script, leaving an address nothing
+     * watches.
+     *
+     * Note the error shape — `WalletCannotAllocateAddressError` is thrown
+     * worker-side and cannot cross the message boundary as a class, so a
+     * `forceNew` refusal surfaces here as a plain `Error` carrying its message
+     * (and the worker-side error as `cause`). Callers that must branch on the
+     * refusal match the message rather than `instanceof`.
+     */
+    getNewAddresses(opts?: GetNewAddressesOptions): Promise<NewAddress[]>;
     /** @see HDWalletCapable.getUsedSigningDescriptors */
     getUsedSigningDescriptors(opts?: {
         lookAhead?: number;
@@ -3827,6 +3912,7 @@ declare class ElectrumOnchainProvider implements OnchainProvider {
      * @returns The broadcast txid (or the child txid for 1P1C packages).
      */
     broadcastTransaction(...txs: string[]): Promise<string>;
+    getRawTransaction(txid: string): Promise<Uint8Array>;
     getTxOutspends(txid: string): Promise<{
         spent: boolean;
         txid: string;
@@ -3873,6 +3959,44 @@ declare class ElectrumOnchainProvider implements OnchainProvider {
     close(): Promise<void>;
 }
 
+/**
+ * Decorates an {@link ArkProvider}, caching {@link ArkProvider.getInfo} for
+ * `ttlMs` (default 60s). Other provider methods pass through.
+ * Expired-cache refresh failures propagate; persisted wallet boot fallback
+ * lives in `arkInfoSnapshot`.
+ */
+declare class CachingArkProvider implements ArkProvider {
+    private readonly inner;
+    private readonly ttlMs;
+    private cached?;
+    private expiresAt;
+    private inflight?;
+    /** Bumped on every event-driven cache write; see {@link getInfo}. */
+    private generation;
+    private readonly unsubscribe;
+    constructor(inner: ArkProvider, ttlMs?: number);
+    /** Releases the inner provider's server-info subscription. */
+    dispose(): void;
+    get serverUrl(): string | undefined;
+    getInfo(): Promise<ArkInfo>;
+    submitTx(signedArkTx: string, checkpointTxs: string[]): Promise<{
+        arkTxid: string;
+        finalArkTx: string;
+        signedCheckpointTxs: string[];
+    }>;
+    finalizeTx(arkTxid: string, finalCheckpointTxs: string[]): Promise<void>;
+    registerIntent(intent: SignedIntent<Intent.RegisterMessage>): Promise<string>;
+    deleteIntent(intent: SignedIntent<Intent.DeleteMessage>): Promise<void>;
+    confirmRegistration(intentId: string): Promise<void>;
+    submitTreeNonces(batchId: string, pubkey: string, nonces: TreeNonces): Promise<void>;
+    submitTreeSignatures(batchId: string, pubkey: string, signatures: TreePartialSigs): Promise<void>;
+    submitSignedForfeitTxs(signedForfeitTxs: string[], signedCommitmentTx?: string): Promise<void>;
+    getEventStream(signal: AbortSignal, topics: string[]): AsyncIterableIterator<SettlementEvent>;
+    getTransactionsStream(signal: AbortSignal): AsyncIterableIterator<TxNotificationEvent>;
+    getPendingTxs(intent: SignedIntent<Intent.GetPendingTxMessage>): Promise<PendingTx[]>;
+    onServerInfoChanged(listener: (info: ArkInfo) => void): () => void;
+}
+
 type ArkTxInput = {
     tapLeafScript: TapLeafScript;
 } & EncodedVtxoScript & Pick<VirtualCoin, "txid" | "vout" | "value">;
@@ -4451,6 +4575,37 @@ declare class TxWeightEstimator {
     vsize(): VSize;
 }
 
+/**
+ * Called when a VTXO's exit becomes observable onchain.
+ *
+ * The seam exists because nothing else can learn the fact: delta sync filters on *creation* time
+ * (`GetVtxosOptions.after` / `before`), so a status change on an older VTXO is invisible to it, and
+ * neither exit path can reach a contract manager on its own — `Unroll.Session` takes no contract
+ * layer by design, and the `UnilateralExit` executor is deliberately keyless and provider-only.
+ *
+ * A plain function type, with no runtime import anywhere in this module, is what lets both keep
+ * that independence: an exit path calls the hook, it does not import the contract layer.
+ *
+ * **Best-effort by contract.** An exit is a disaster-recovery path and must never fail because a
+ * cache write did, so every call site goes through {@link notifyExitObserved}.
+ */
+type OnExitObserved = (outpoint: Outpoint) => void | Promise<void>;
+/**
+ * Adapt a contract manager into an {@link OnExitObserved}: the wallet-side half of the seam, kept
+ * out of `exit/` so the dependency direction stays outward.
+ *
+ * **A prompt, not a guarantee.** The hook fires when the EXPLORER reports the exit confirmed, and
+ * `refreshOutpoints` then asks the INDEXER. If arkd has not yet marked the output `isUnrolled` the
+ * refresh writes the state it does report — or returns silently when it names no vtxo at all — and
+ * nothing here retries. A miss leaves the wallet exactly where it was before this seam existed: it
+ * learns the exit whenever something else next refreshes the outpoint. The executor's second fire
+ * at sweep-confirm is the natural retry, and by then the exit has been onchain for at least the
+ * CSV delay.
+ */
+declare function exitObserverFor(manager: Pick<IContractManager, "refreshOutpoints">): OnExitObserved;
+/** Fire an observation without letting it into the exit's failure path. */
+declare function notifyExitObserved(onExitObserved: OnExitObserved | undefined, outpoint: Outpoint): Promise<void>;
+
 declare namespace Unroll {
     enum StepType {
         UNROLL = 0,
@@ -4528,6 +4683,16 @@ declare namespace Unroll {
          * previous behaviour (indexer only).
          */
         readonly virtualTxRepository?: VirtualTxRepository | undefined;
+        /**
+         * Fired once the chain is fully onchain (`StepType.DONE`), so a
+         * wallet repository can be prompted to re-read the outpoint —
+         * delta sync never would, filtering as it does on creation time.
+         * Fired ONCE, so an observer that reads a lagging indexer gets no
+         * second chance; see {@link exitObserverFor}. Best-effort — a
+         * rejection never reaches the exit. Prefer {@link sessionFor},
+         * which wires it from the wallet.
+         */
+        readonly onExitObserved?: OnExitObserved | undefined;
         /** Create an unroll session from a virtual output outpoint and its dependency chain. */
         constructor(toUnroll: Outpoint & {
             chain: ChainTx[];
@@ -4538,9 +4703,19 @@ declare namespace Unroll {
          * miss, then cached best-effort for later exits. Omitted ⇒ exact
          * previous behaviour (indexer only).
          */
-        virtualTxRepository?: VirtualTxRepository | undefined);
+        virtualTxRepository?: VirtualTxRepository | undefined, 
+        /**
+         * Fired once the chain is fully onchain (`StepType.DONE`), so a
+         * wallet repository can be prompted to re-read the outpoint —
+         * delta sync never would, filtering as it does on creation time.
+         * Fired ONCE, so an observer that reads a lagging indexer gets no
+         * second chance; see {@link exitObserverFor}. Best-effort — a
+         * rejection never reaches the exit. Prefer {@link sessionFor},
+         * which wires it from the wallet.
+         */
+        onExitObserved?: OnExitObserved | undefined);
         /** Create an unroll session by loading the virtual output chain from the indexer. */
-        static create(toUnroll: Outpoint, bumper: AnchorBumper, explorer: OnchainProvider, indexer: IndexerProvider, virtualTxRepository?: VirtualTxRepository): Promise<Session>;
+        static create(toUnroll: Outpoint, bumper: AnchorBumper, explorer: OnchainProvider, indexer: IndexerProvider, virtualTxRepository?: VirtualTxRepository, onExitObserved?: OnExitObserved): Promise<Session>;
         /**
          * Resolve a chain tx's raw PSBT (base64). Repo first when configured;
          * indexer on a miss, then best-effort cached so a later exit doesn't
@@ -4550,6 +4725,14 @@ declare namespace Unroll {
         private resolveVirtualTxBase64;
         /**
          * Get the next step to be executed
+         *
+         * @remarks
+         * `do()` is the step, not a formality: every effect lives there, and at
+         * `StepType.DONE` that includes firing {@link onExitObserved}. A caller
+         * driving `next()` by hand must always await it — the async iterator
+         * below does. Reading `type` and skipping `do()` leaves the exit
+         * unobserved, and on the other step kinds unbroadcast.
+         *
          * @returns The next step to be executed + the function to execute it
          */
         next(): Promise<Step & {
@@ -4561,6 +4744,16 @@ declare namespace Unroll {
          */
         [Symbol.asyncIterator](): AsyncIterator<Step>;
     }
+    /**
+     * {@link Session.create} with everything the wallet already holds — explorer, indexer,
+     * virtual-tx cache — plus the exit observer, which re-reads the outpoint at `StepType.DONE`
+     * rather than waiting for a delta sync that cannot see the change. That single fire is a
+     * prompt and not a guarantee — see {@link exitObserverFor}.
+     *
+     * Prefer this to building a `Session` by hand: an optional parameter only reaches callers who
+     * know to pass it, which is the same failure mode the seam exists to close.
+     */
+    function sessionFor(wallet: Wallet, toUnroll: Outpoint, bumper: AnchorBumper): Promise<Session>;
     /**
      * Complete the unroll of a virtual output by broadcasting the transaction that spends the CSV path.
      * @param wallet the wallet owning the virtual output(s)
@@ -4734,6 +4927,32 @@ type ExecutorEvent = {
 interface ExitFeeWallet {
     bumpAnchor(parentHex: string, feeRate: number): Promise<[parentHex: string, childHex: string]>;
 }
+interface ExecutorOptions {
+    pollIntervalMs?: number;
+    feeWallet?: ExitFeeWallet;
+    /** Abort to stop execution.
+     *
+     * Iteration then rejects with `signal.reason`. Calling `abort()`
+     * with no argument yields an error whose `name` is `"AbortError"`;
+     * a custom reason is forwarded as-is, matching `fetch` and
+     * `AbortSignal.prototype.throwIfAborted`.
+     *
+     * Already-broadcast transactions are not recalled; the executor is
+     * idempotent, so a later run resumes from the chain. */
+    signal?: AbortSignal;
+    /**
+     * Fired per VTXO once every step serving its branch is onchain, and again
+     * once its sweep confirms — the two moments an exit becomes observable.
+     * Two fires rather than one is what makes an observer reading a lagging
+     * indexer recoverable here: by the sweep the exit has been onchain for at
+     * least the CSV delay.
+     *
+     * Best-effort: a rejection never reaches the exit, which is the whole point
+     * of a keyless disaster-recovery path. `UnilateralExit.execute` wires it
+     * from a wallet; passing it here keeps the bare executor provider-only.
+     */
+    onExitObserved?: OnExitObserved;
+}
 /**
  * Keyless, stateless executor for a pre-signed exit package.
  *
@@ -4747,20 +4966,15 @@ declare class Executor implements AsyncIterable<ExecutorEvent> {
     private readonly pollIntervalMs;
     private readonly feeWallet?;
     private readonly signal?;
-    constructor(pkg: ExitPackage, provider: OnchainProvider, opts?: {
-        pollIntervalMs?: number;
-        feeWallet?: ExitFeeWallet;
-        /** Abort to stop execution.
-         *
-         * Iteration then rejects with `signal.reason`. Calling `abort()`
-         * with no argument yields an error whose `name` is `"AbortError"`;
-         * a custom reason is forwarded as-is, matching `fetch` and
-         * `AbortSignal.prototype.throwIfAborted`.
-         *
-         * Already-broadcast transactions are not recalled; the executor is
-         * idempotent, so a later run resumes from the chain. */
-        signal?: AbortSignal;
-    });
+    private readonly onExitObserved?;
+    constructor(pkg: ExitPackage, provider: OnchainProvider, opts?: ExecutorOptions);
+    /**
+     * Per-VTXO branch progress, which the executor otherwise does not track:
+     * `dead` / `done` are per-step, and a VTXO is only onchain once EVERY
+     * `package`/`bump` step naming it has confirmed. (`broadcast` — the funding
+     * splitter — carries no `forVtxos` and serves no single VTXO.)
+     */
+    private branchSteps;
     /**
      * Poll delay. Nearly all wall-clock time is spent here, so it must be the
      * thing that reacts to abort — checking only between polls would leave
@@ -4770,8 +4984,25 @@ declare class Executor implements AsyncIterable<ExecutorEvent> {
     private status;
     private waitConfirmed;
     [Symbol.asyncIterator](): AsyncIterator<ExecutorEvent>;
+    /** `"txid:vout"` -> outpoint, then hand it to the hook. A malformed entry is skipped. */
+    private observe;
 }
 
+/**
+ * An {@link Executor} with the wallet's exit observer already wired, so the repository re-reads
+ * each outpoint as its branch confirms and again as its sweep does, moving the value into the
+ * `unrolled` balance bucket without waiting for a delta sync — which could not see the change
+ * anyway, filtering as it does on creation time. What the re-read learns depends on the indexer
+ * having caught up; see `exitObserverFor`.
+ *
+ * The bare `Executor` stays keyless and provider-only; this is the wallet-side convenience that
+ * makes the default path correct, because an opt-in parameter only reaches callers who know to pass
+ * it. An explicit `opts.onExitObserved` still wins.
+ */
+declare function execute(wallet: Wallet, pkg: ExitPackage, opts?: ExecutorOptions & {
+    provider?: OnchainProvider;
+}): Promise<Executor>;
+
 /**
  * Build the fully pre-signed unilateral exit package.
  *
@@ -4791,10 +5022,17 @@ declare function prepare(opts: ExitOptions): Promise<ExitPackage>;
  * VTXOs onchain and broadcasts the fee-funding splitter; `Executor` drives
  * the resulting package to completion with nothing but an
  * Esplora-compatible endpoint — no keys, no Arkade infrastructure.
+ *
+ * `execute` is the wallet-side shorthand for that last step: the same
+ * executor, with the exit observer wired so the wallet's own repository
+ * re-reads each outpoint as its branch confirms and again as its sweep
+ * does — picking the exit up as it lands, indexer lag permitting. See
+ * `exitObserverFor` for why that is a prompt rather than a guarantee.
  */
 declare const UnilateralExit: {
     readonly estimate: typeof estimate;
     readonly prepare: typeof prepare;
+    readonly execute: typeof execute;
     readonly Executor: typeof Executor;
 };
 
@@ -5379,6 +5617,11 @@ declare namespace bignum {
  * 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.
+ *
  * @example
  * ```typescript
  * const htlcProgram = {
@@ -5434,10 +5677,13 @@ interface Utxo {
     vout: number;
     value: number;
     /**
-     * The ark transaction that created this VTXO. Required only by continuation
-     * /recursive covenants that inspect the input's provenance; when set, the SDK
-     * attaches it as the PrevArkTx field.
+     * 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.
      */
     sourceTx?: Uint8Array;
 }
@@ -5483,8 +5729,12 @@ interface ArkadeConnectOptions {
      * tapscript contracts (multisig/timelock/hashlock) don't need it.
      */
     emulator?: EmulatorProvider;
-    /** Indexer — enables `getUtxos`/`getBalance` and coin auto-selection. */
-    indexer?: Pick<IndexerProvider, "getVtxos">;
+    /**
+     * Indexer — enables `getUtxos`/`getBalance` and coin auto-selection, and
+     * resolves the previous ark txs a covenant spend must carry (see
+     * {@link attachPrevArkTxs}). Required for covenant spends.
+     */
+    indexer?: Pick<IndexerProvider, "getVtxos" | "getVirtualTxs">;
     /** Signer for paths that require a user signature; optional for watch-only. */
     identity?: Identity;
     /** Network for address derivation; defaults to the SDK default. */
@@ -5534,7 +5784,7 @@ declare class Arkade {
      */
     readonly emulatorKey: Uint8Array | undefined;
     readonly checkpoint: CSVMultisigTapscript.Type;
-    readonly indexer?: Pick<IndexerProvider, "getVtxos">;
+    readonly indexer?: Pick<IndexerProvider, "getVtxos" | "getVirtualTxs">;
     readonly identity?: Identity;
     /** The signing identity's x-only public key, resolved at connect — identifies which inputs the wallet signs. */
     readonly userKey?: Uint8Array;
@@ -6046,6 +6296,27 @@ declare function timelockToSequence(timelock: RelativeTimelock): number;
  */
 declare function sequenceToTimelock(sequence: number): RelativeTimelock;
 
+/**
+ * Normalize a secp256k1 public key to the 32-byte x-only form every tapscript,
+ * covenant param and `params.serverPubKey` in this SDK is denominated in.
+ *
+ * A compressed key drops its parity prefix; an x-only key passes through. Both
+ * arrive over the same wires — arkd advertises `signerPubkey` either way,
+ * `Identity.xOnlyPublicKey` implementations vary, and solver-supplied fields
+ * are whatever the peer sent — so the caller usually cannot know which it
+ * holds. Anything else is refused rather than silently truncated: a 65-byte
+ * uncompressed key, stripped of one byte, yields a plausible 32-byte value
+ * that is not the key, which surfaces as an address nobody funded.
+ *
+ * The result may alias `key` rather than copy it; callers that mutate either
+ * value after normalization should copy first.
+ *
+ * @param key - 32-byte x-only or 33-byte compressed public key
+ * @param label - Name used in the error, e.g. `"ark signer key"`
+ * @see toXOnlySignerHex for the hex-in, hex-out signer-rotation equivalent
+ */
+declare function toXOnly(key: Uint8Array, label?: string): Uint8Array;
+
 declare const buildVersion = "0.9.9";
 /**
  * The SDK's own version string, sourced from package.json
@@ -6276,4 +6547,4 @@ declare class AssetManager extends ReadonlyAssetManager implements IAssetManager
     burn(params: BurnParams): Promise<string>;
 }
 
-export { ARKADE_MAGIC, ARKADE_SALTED_PREIMAGE_TAG, ARKADE_SWAP_PREIMAGE_TAG, Activity, ActivityRegistry, AmbiguousRouteError, type AnchorBumper, ArkAddress, ArkIntent, ArkNote, ArkProvider, type ArkPsbtFieldCoder, ArkPsbtFieldKey, ArkPsbtFieldKeyType, ArkTransaction, type ArkTxInput, type ArkadeBatchInput, ArkadeCash, ArkadeContractParams, type ArkadeExtendedCoin, type ArkadeExtendedVirtualCoin, Asset, AssetDetails, AssetManager, BIP21, BIP21Error, type BIP21Params, type BIP21ParseResult, BIP322, BLOCKED_UPGRADE_TIMEOUT_MS, Batch, BatchExpiryPolicy, BurnParams, CSVMultisigTapscript, ChainTx, Coin, ConditionWitness, ConnectionDisposedError, type ConnectorTreeNode, Contract, ContractEvent, ContractRepository, ContractRepositoryImpl, ContractSyncState, ContractWatcherConfig, ContractWithVtxos, CosignerPublicKey, CreateContractParams, DEFAULT_MESSAGE_TIMEOUTS, DatabaseUpgradeBlockedError, DefaultVtxo, DelegateInfo, DelegateNotConfiguredError, DelegatorNotConfiguredError, 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 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, GetVtxosFilter, 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, MIGRATION_KEY, type ManagedConnection, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, type MessageHandler, type MessageTimeouts, MigrationGlobalSkipReason, MigrationLegSkipReason, type MigrationStatus, MissingSigningDescriptorError, MnemonicIdentity, type MnemonicOptions, Network, NetworkName, type NetworkOptions, OffchainInput, type OffchainTx, OnchainInput, OnchainProvider, OnchainWallet, Outpoint, P2A, type ParsedArkContract, PathContext, PathSelection, type PaymentHandle, type PaymentOption, type PaymentRail, type PaymentRequest, PaymentRouter, type PaymentStatus, PrevArkTxField, PrevoutTxField, ProviderConnectionState, type ProvisionedClaimSecret, type ProvisionedKey, 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, SignerSession, SignerStatus, SingleKey, Status, StorageConfig, TapLeafScript, Transaction, 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, WalletRepositoryImpl, WsElectrumChainSource, adoptContractDescriptor, arkRail, arkTarget, index as arkade, assembleBtcdTaprootTree, assertFinalCommitmentMatchesValidated, assertSendableAmount, assertSubmittedArkTxid, index$1 as asset, awaitTransaction, btcTarget, buildForfeitTx, buildOffchainTx, buildPreimageMessage, buildSaltedPreimageMessage, buildVersion, claimWithPreimageIdentity, closeDatabase, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, contractPreimage, contractSigner, createAssetPacket, createDefaultPaymentRouter, createManagedConnection, decodeArkContract, deleteByIndex, deriveDescriptorLeafCompressedPubKey, deriveDescriptorLeafPubKey, deserializeExitPackage, encodeArkContract, gateExclusion, gatedContracts, getAllByIndexValues, getArkPsbtFields, getMigrationStatus, hasBoardingTxExpired, identityDescriptor, invoiceTarget, isArkContract, isBtcAddress, isCltvSatisfied, isContractGenericallySpendable, isCsvSpendable, isDeterministicSigner, isHDDeterministicSignCapable, isLightningInvoice, isLnurl, isMessageBusInitializingError, isMessageBusNotInitializedError, isPerArtifactDescriptor, isRetryableProviderError, isValidArkAddress, logExcludedVtxos, makeHandle, matchServerCheckpoints, migrateWalletRepository, normalizeToDescriptor, onchainRail, openDatabase, outpointExclusion, outpointReasons, parseHDDescriptor, promisifyRequest, provisionClaimSecret, provisionRefundKey, requiresMigration, resolveSendAmount, rollbackMigration, sdkVersion, selectCoinsWithAsset, sequenceToTimelock, serializeExitPackage, setArkPsbtField, setupServiceWorker, signAndSubmitOffchainTx, timelockToSequence, tryResolveSendAmount, validateBatchRecipients, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures };
+export { ARKADE_MAGIC, ARKADE_SALTED_PREIMAGE_TAG, ARKADE_SWAP_PREIMAGE_TAG, Activity, ActivityRegistry, AddressAllocationCapable, AmbiguousRouteError, type AnchorBumper, ArkAddress, ArkInfo, ArkIntent, ArkNote, ArkProvider, type ArkPsbtFieldCoder, ArkPsbtFieldKey, ArkPsbtFieldKeyType, ArkTransaction, type ArkTxInput, type ArkadeBatchInput, ArkadeCash, ArkadeContractParams, type ArkadeExtendedCoin, type ArkadeExtendedVirtualCoin, 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, ContractRepositoryImpl, ContractSyncState, ContractWatcherConfig, ContractWithVtxos, CosignerPublicKey, CreateContractParams, DEFAULT_MESSAGE_TIMEOUTS, DatabaseUpgradeBlockedError, DefaultVtxo, DelegateInfo, DelegateNotConfiguredError, DelegatorNotConfiguredError, 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, GetNewAddressesOptions, GetVtxosFilter, 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, MIGRATION_KEY, type ManagedConnection, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, type MessageHandler, type MessageTimeouts, MigrationGlobalSkipReason, MigrationLegSkipReason, type MigrationStatus, MissingSigningDescriptorError, MnemonicIdentity, type MnemonicOptions, Network, NetworkName, type NetworkOptions, NewAddress, OffchainInput, type OffchainTx, type OnExitObserved, OnchainInput, OnchainProvider, OnchainWallet, Outpoint, P2A, type ParsedArkContract, PathContext, PathSelection, type PaymentHandle, type PaymentOption, type PaymentRail, type PaymentRequest, PaymentRouter, type PaymentStatus, PrevArkTxField, PrevoutTxField, ProviderConnectionState, type ProvisionedClaimSecret, type ProvisionedKey, 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, WalletRepositoryImpl, WsElectrumChainSource, adoptContractDescriptor, arkRail, arkTarget, index as arkade, assembleBtcdTaprootTree, assertFinalCommitmentMatchesValidated, assertSendableAmount, assertSubmittedArkTxid, index$1 as asset, 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, getMigrationStatus, hasBoardingTxExpired, identityDescriptor, invoiceTarget, isArkContract, isBtcAddress, isCltvSatisfied, isContractGenericallySpendable, isCsvSpendable, isDeterministicSigner, isHDDeterministicSignCapable, isLightningInvoice, isLnurl, isMessageBusInitializingError, isMessageBusNotInitializedError, isPerArtifactDescriptor, isRetryableProviderError, isValidArkAddress, logExcludedVtxos, makeHandle, matchServerCheckpoints, migrateWalletRepository, normalizeToDescriptor, notifyExitObserved, onchainRail, openDatabase, outpointExclusion, outpointReasons, parseHDDescriptor, promisifyRequest, provisionClaimSecret, provisionRefundKey, requiresMigration, resolveSendAmount, rollbackMigration, sdkVersion, selectCoinsWithAsset, sequenceToTimelock, serializeExitPackage, setArkPsbtField, setupServiceWorker, signAndSubmitOffchainTx, timelockToSequence, toXOnly, tryResolveSendAmount, validateBatchRecipients, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures };